@oscarpalmer/timer 0.5.0 → 0.8.0

package/README.md

@@ -1,7 +1,47 @@
 # Timer
 
-A better timer?
+[![npm version](https://badge.fury.io/js/@oscarpalmer%2Ftimer.svg)](https://badge.fury.io/js/@oscarpalmer%2Ftimer)
+
+A better solution for timeout- and interval-based timers.
+
+## Installation
+
+Timer is available on _npm_ as [`@oscarpalmer/timer`](https://www.npmjs.com/package/@oscarpalmer/timer).
+
+## Getting started
+
+This is fairly lightweight package, so hopefully you'll be up and running in seconds :blush:
+
+### Examples
+
+The timers can be called with nice helper methods, which also auto-starts the timers:
+
+```typescript
+import {repeat, wait} from '@oscarpalmer/timer';
+
+let waited = wait(callback, time);
+let repeated = repeat(callback, time, count);
+```
+
+Or they can be created using class syntax, but without being auto-started:
+
+```typescript
+import {Repeated, Waited} from '@oscarpalmer/timer';
+
+waited = new Waited(callback, time);
+repeated = new Repeated(callback, time, count);
+```
+
+## Methods
+
+Both the nice helper methods and the class syntax create similar objects – `Waited` and `Repeated` – which share methods:
+
+|Method|Description|
+|-----:|:----------|
+|`start()`|Starts the timer: necessary when creating a timer using the class syntax _(e.g. `new Waited...`)_, but helpful when the timer needs to be started at other times, as well|
+|`stop()`|Stops the timer|
+|`restart()`|Restarts the timer|
 
 ## License
 
-[MI licensed](LICENSE), natch :blush:
+[MIT licensed](LICENSE), natch :wink:

package/dist/timer.cjs.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Repeated: () => Repeated,
+  Waited: () => Waited,
+  repeat: () => repeat,
+  wait: () => wait
+});
+module.exports = __toCommonJS(src_exports);
+var milliseconds = Math.round(1e3 / 60);
+var Timed = class {
+  constructor(type, callback, time, count) {
+    __publicField(this, "callback");
+    __publicField(this, "count");
+    __publicField(this, "frame");
+    __publicField(this, "running", false);
+    __publicField(this, "time");
+    __publicField(this, "type");
+    if (typeof callback !== "function") {
+      throw new Error(`A ${type} timer must have a callback function`);
+    }
+    if (typeof time !== "number" || time < 0) {
+      throw new Error(`A ${type} timer must have a non-negative number as its time`);
+    }
+    if (type === "repeated" && (typeof count !== "number" || count < 2)) {
+      throw new Error(`A ${type} timer must have a number above 1 as its repeat count`);
+    }
+    this.type = type;
+    this.callback = callback;
+    this.time = time;
+    this.count = count;
+  }
+  get active() {
+    return this.running;
+  }
+  restart() {
+    this.stop();
+    Timed.run(this);
+    return this;
+  }
+  start() {
+    if (this.running) {
+      return this;
+    }
+    Timed.run(this);
+    return this;
+  }
+  stop() {
+    this.running = false;
+    if (typeof this.frame === "undefined") {
+      return this;
+    }
+    window.cancelAnimationFrame(this.frame);
+    this.frame = void 0;
+    return this;
+  }
+  static run(timed) {
+    timed.running = true;
+    let count = 0;
+    let start;
+    function step(timestamp) {
+      if (!timed.running) {
+        return;
+      }
+      start ?? (start = timestamp);
+      const elapsed = timestamp - start;
+      const elapsedMinimum = elapsed - milliseconds;
+      const elapsedMaximum = elapsed + milliseconds;
+      if (elapsedMinimum < timed.time && timed.time < elapsedMaximum) {
+        if (timed.running) {
+          timed.callback(timed.type === "repeated" ? count : void 0);
+        }
+        count += 1;
+        if (timed.type === "repeated" && count < timed.count) {
+          start = void 0;
+        } else {
+          timed.stop();
+          return;
+        }
+      }
+      timed.frame = window.requestAnimationFrame(step);
+    }
+    timed.frame = window.requestAnimationFrame(step);
+  }
+};
+var Repeated = class extends Timed {
+  constructor(callback, time, count) {
+    super("repeated", callback, time, count);
+  }
+};
+var Waited = class extends Timed {
+  constructor(callback, time) {
+    super("waited", callback, time, 1);
+  }
+};
+function repeat(callback, time, count) {
+  return new Repeated(callback, time, count).start();
+}
+function wait(callback, time) {
+  return new Waited(callback, time).start();
+}

package/dist/timer.iife.js

@@ -0,0 +1,127 @@
+"use strict";
+var Timer = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    Repeated: () => Repeated,
+    Waited: () => Waited,
+    repeat: () => repeat,
+    wait: () => wait
+  });
+  var milliseconds = Math.round(1e3 / 60);
+  var Timed = class {
+    constructor(type, callback, time, count) {
+      __publicField(this, "callback");
+      __publicField(this, "count");
+      __publicField(this, "frame");
+      __publicField(this, "running", false);
+      __publicField(this, "time");
+      __publicField(this, "type");
+      if (typeof callback !== "function") {
+        throw new Error(`A ${type} timer must have a callback function`);
+      }
+      if (typeof time !== "number" || time < 0) {
+        throw new Error(`A ${type} timer must have a non-negative number as its time`);
+      }
+      if (type === "repeated" && (typeof count !== "number" || count < 2)) {
+        throw new Error(`A ${type} timer must have a number above 1 as its repeat count`);
+      }
+      this.type = type;
+      this.callback = callback;
+      this.time = time;
+      this.count = count;
+    }
+    get active() {
+      return this.running;
+    }
+    restart() {
+      this.stop();
+      Timed.run(this);
+      return this;
+    }
+    start() {
+      if (this.running) {
+        return this;
+      }
+      Timed.run(this);
+      return this;
+    }
+    stop() {
+      this.running = false;
+      if (typeof this.frame === "undefined") {
+        return this;
+      }
+      window.cancelAnimationFrame(this.frame);
+      this.frame = void 0;
+      return this;
+    }
+    static run(timed) {
+      timed.running = true;
+      let count = 0;
+      let start;
+      function step(timestamp) {
+        if (!timed.running) {
+          return;
+        }
+        start ?? (start = timestamp);
+        const elapsed = timestamp - start;
+        const elapsedMinimum = elapsed - milliseconds;
+        const elapsedMaximum = elapsed + milliseconds;
+        if (elapsedMinimum < timed.time && timed.time < elapsedMaximum) {
+          if (timed.running) {
+            timed.callback(timed.type === "repeated" ? count : void 0);
+          }
+          count += 1;
+          if (timed.type === "repeated" && count < timed.count) {
+            start = void 0;
+          } else {
+            timed.stop();
+            return;
+          }
+        }
+        timed.frame = window.requestAnimationFrame(step);
+      }
+      timed.frame = window.requestAnimationFrame(step);
+    }
+  };
+  var Repeated = class extends Timed {
+    constructor(callback, time, count) {
+      super("repeated", callback, time, count);
+    }
+  };
+  var Waited = class extends Timed {
+    constructor(callback, time) {
+      super("waited", callback, time, 1);
+    }
+  };
+  function repeat(callback, time, count) {
+    return new Repeated(callback, time, count).start();
+  }
+  function wait(callback, time) {
+    return new Waited(callback, time).start();
+  }
+  return __toCommonJS(src_exports);
+})();

package/dist/timer.js

@@ -1,4 +1,3 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
@@ -7,7 +6,7 @@ var __publicField = (obj, key, value) => {
 };
 
 // src/index.ts
-var milliseconds = 1e3 / 60;
+var milliseconds = Math.round(1e3 / 60);
 var Timed = class {
   constructor(type, callback, time, count) {
     __publicField(this, "callback");
@@ -93,16 +92,15 @@ var Waited = class extends Timed {
     super("waited", callback, time, 1);
   }
 };
-var Timer = {
-  repeat: (callback, time, count) => {
-    return new Repeated(callback, time, count).start();
-  },
-  wait: (callback, time) => {
-    return new Waited(callback, time).start();
-  }
-};
+function repeat(callback, time, count) {
+  return new Repeated(callback, time, count).start();
+}
+function wait(callback, time) {
+  return new Waited(callback, time).start();
+}
 export {
   Repeated,
-  Timer,
-  Waited
+  Waited,
+  repeat,
+  wait
 };

package/package.json

@@ -3,24 +3,30 @@
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
-	"description": "A better timer?",
+	"browser": "dist/timer.iife.js",
+	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
 		"@tsconfig/recommended": "^1.0.0",
-		"@types/node": "^18.0.0",
-		"@typescript-eslint/eslint-plugin": "^5.30.0",
-		"@typescript-eslint/parser": "^5.30.0",
-		"esbuild": "^0.14.0",
-		"eslint": "^8.19.0",
-		"eslint-config-xo": "^0.41.0",
-		"eslint-config-xo-typescript": "^0.51.0",
-		"typescript": "^4.7.0"
+		"@types/node": "^18.7.0",
+		"@typescript-eslint/eslint-plugin": "^5.36.0",
+		"@typescript-eslint/parser": "^5.36.0",
+		"esbuild": "^0.15.0",
+		"eslint": "^8.23.0",
+		"eslint-config-xo": "^0.42.0",
+		"eslint-config-xo-typescript": "^0.53.0",
+		"typescript": "^4.8.0"
 	},
 	"exports": {
 		".": {
+			"types": "./src/index.d.ts",
+			"script": "./dist/timer.iife.js",
+			"module": "./dist/timer.js",
 			"import": "./dist/timer.js",
-			"require": "./dist/timer.js"
+			"require": "./dist/timer.cjs.js",
+			"default": "./dist/timer.js"
 		}
 	},
+	"files": ["dist", "src/index.d.ts"],
 	"jsdelivr": "dist/timer.js",
 	"keywords": [
 		"timer",
@@ -29,7 +35,7 @@
 		"requestAnimationFrame"
 	],
 	"license": "MIT",
-	"main": "dist/timer.js",
+	"main": "dist/timer.cjs.js",
 	"module": "dist/timer.js",
 	"name": "@oscarpalmer/timer",
 	"repository": {
@@ -37,11 +43,14 @@
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.js --format=esm",
+		"build": "npm run build:cjs; npm run build:esm; npm run build:iife",
+		"build:cjs": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.cjs.js --format=cjs",
+		"build:esm": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.js --format=esm",
+		"build:iife": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.iife.js --format=iife --global-name=Timer",
 		"watch": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.js --format=esm --watch"
 	},
 	"type": "module",
 	"types": "src/index.d.ts",
 	"unpkg": "dist/timer.js",
-	"version": "0.5.0"
-}
+	"version": "0.8.0"
+}

package/src/index.d.ts

@@ -1,18 +1 @@
-type RepeatedCallback = (index: number) => void;
-type WaitedCallback = () => void;
-
-interface Timed<Callback> {
-	get active(): boolean;
-	constructor(callback: Callback, time: number, count: number): void;
-	restart(): void;
-	start(): void;
-	stop(): void;
-}
-
-export interface Repeated extends Timed<RepeatedCallback> {}
-export interface Waited extends Timed<WaitedCallback> {}
-
-export interface Timer {
-	repeated(callback: RepeatedCallback, time: number, count: number): Repeated;
-	waited(callback: WaitedCallback, time: number): Waited;
-}
+export * from './index';

package/.eslintrc.json

@@ -1,44 +0,0 @@
-{
-	"root": true,
-	"extends": [
-		"xo",
-		"xo-typescript"
-	],
-	"parser": "@typescript-eslint/parser",
-	"parserOptions": {
-		"project": [
-			"./tsconfig.json"
-		]
-	},
-	"plugins": [
-		"@typescript-eslint"
-	],
-	"rules": {
-		"@typescript-eslint/member-ordering": [
-			"error",
-			{
-				"default": [
-					"signature",
-
-					"private-decorated-field", "protected-decorated-field", "public-decorated-field", "decorated-field",
-
-					"private-static-field", "protected-static-field", "public-static-field", "static-field",
-
-					["private-abstract-field", "private-instance-field", "private-field"],
-					["protected-abstract-field", "protected-instance-field", "protected-field"],
-					["public-abstract-field", "public-instance-field", "public-field"],
-					["abstract-field", "instance-field", "field"],
-
-					"private-constructor", "protected-constructor", "public-constructor", "constructor",
-
-					["public-abstract-method", "public-decorated-method", "public-instance-method", "public-method"],
-					["protected-abstract-method", "protected-decorated-method", "protected-instance-method", "protected-method"],
-					["private-abstract-method", "private-decorated-method", "private-instance-method", "private-method"],
-					["abstract-method", "decorated-method", "instance-method", "method"],
-
-					"static-method", "public-static-method", "protected-static-method", "private-static-method"
-				]
-			}
-		]
-	},
-}

package/src/index.ts

@@ -1,132 +0,0 @@
-type RepeatedCallback = (index: number) => void;
-type TimerType = 'repeated' | 'waited';
-type WaitedCallback = () => void;
-
-const milliseconds = 1000 / 60;
-
-abstract class Timed<Callback> {
-	private readonly callback: Callback;
-	private readonly count: number;
-	private frame: number | undefined;
-	private running = false;
-	private readonly time: number;
-	private readonly type: TimerType;
-
-	get active(): boolean {
-		return this.running;
-	}
-
-	protected constructor(type: TimerType, callback: Callback, time: number,	count: number) {
-		if (typeof callback !== 'function') {
-			throw new Error(`A ${type} timer must have a callback function`);
-		}
-
-		if (typeof time !== 'number' || time < 0) {
-			throw new Error(`A ${type} timer must have a non-negative number as its time`);
-		}
-
-		if (type === 'repeated' && (typeof count !== 'number' || count < 2)) {
-			throw new Error(`A ${type} timer must have a number above 1 as its repeat count`);
-		}
-
-		this.type = type;
-		this.callback = callback;
-		this.time = time;
-		this.count = count;
-	}
-
-	restart(): Timed<Callback> {
-		this.stop();
-
-		Timed.run(this as never);
-
-		return this;
-	}
-
-	start(): Timed<Callback> {
-		if (this.running) {
-			return this;
-		}
-
-		Timed.run(this as never);
-
-		return this;
-	}
-
-	stop(): Timed<Callback> {
-		this.running = false;
-
-		if (typeof this.frame === 'undefined') {
-			return this;
-		}
-
-		window.cancelAnimationFrame(this.frame);
-
-		this.frame = undefined;
-
-		return this;
-	}
-
-	private static run(timed: Timed<(index: number | undefined) => void>): void {
-		timed.running = true;
-
-		let count = 0;
-
-		let start: DOMHighResTimeStamp | undefined;
-
-		function step(timestamp: DOMHighResTimeStamp): void {
-			if (!timed.running) {
-				return;
-			}
-
-			start ??= timestamp;
-
-			const elapsed = timestamp - start;
-
-			const elapsedMinimum = elapsed - milliseconds;
-			const elapsedMaximum = elapsed + milliseconds;
-
-			if (elapsedMinimum < timed.time && timed.time < elapsedMaximum) {
-				if (timed.running) {
-					timed.callback(timed.type === 'repeated' ? count : undefined);
-				}
-
-				count += 1;
-
-				if (timed.type === 'repeated' && count < timed.count) {
-					start = undefined;
-				} else {
-					timed.stop();
-
-					return;
-				}
-			}
-
-			timed.frame = window.requestAnimationFrame(step);
-		}
-
-		timed.frame = window.requestAnimationFrame(step);
-	}
-}
-
-export class Repeated extends Timed<RepeatedCallback> {
-	constructor(callback: RepeatedCallback, time: number, count: number) {
-		super('repeated', callback, time, count);
-	}
-}
-
-export class Waited extends Timed<WaitedCallback> {
-	constructor(callback: WaitedCallback, time: number) {
-		super('waited', callback, time, 1);
-	}
-}
-
-export const Timer = {
-	repeat: (callback: RepeatedCallback, time: number, count: number): Repeated => {
-		return (new Repeated(callback, time, count)).start();
-	},
-
-	wait: (callback: WaitedCallback, time: number): Waited => {
-		return (new Waited(callback, time)).start();
-	},
-}

package/test/index.html

@@ -1,24 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<title>Mocha Tests</title>
-		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-		<link rel="stylesheet" href="https://unpkg.com/mocha/mocha.css" />
-	</head>
-	<body>
-		<div id="mocha"></div>
-
-		<script src="https://unpkg.com/chai/chai.js"></script>
-		<script src="https://unpkg.com/mocha/mocha.js"></script>
-
-		<script class="mocha-init">
-			mocha.setup('bdd');
-			mocha.checkLeaks();
-		</script>
-		<script src="test/test.js" type="module"></script>
-		<script class="mocha-exec">
-			mocha.run();
-		</script>
-	</body>
-</html>

package/test/test.js

@@ -1,121 +0,0 @@
-import {Repeated, Timer, Waited} from '../dist/timer.js';
-
-describe('Timer, factory', function () {
-  it('should create and start a repeated timer', function () {
-		chai.assert.ok(Timer.repeat(() => {}, 0, 2) instanceof Repeated);
-	});
-
-	it('should create and start a waited timer', function () {
-		chai.assert.ok(Timer.wait(() => {}, 0) instanceof Waited);
-	});
-});
-
-describe('Timer, Repeated', function () {
-	describe('Constructor', function () {
-		it('should create a proper repeated timer', function () {
-			chai.assert.ok(new Repeated(() => {}, 0, 2) instanceof Repeated);
-		});
-	
-		it('should handle bad parameters', function () {
-			chai.assert.throws(function () { new Repeated(null, null, null); }, /callback/);
-			chai.assert.throws(function () { new Repeated(() => {}, null, null); }, /time/);
-			chai.assert.throws(function () { new Repeated(() => {}, 0, null); }, /count/);
-			chai.assert.throws(function () { new Repeated(() => {}, 0, 1); }, /count/);
-		});
-	});
-
-	describe('Run', function () {
-		it('should run as many times as set', function (done) {
-			let value = 0;
-
-			Timer.repeat(() => {
-				value += 1;
-			}, 25, 10);
-
-			Timer.wait(() => {
-				chai.assert.equal(value, 10);
-
-				done();
-			}, 500);
-		});
-
-		it('should run until canceled', function (done) {
-			let value = 0;
-
-			const repeated = Timer.repeat(() => {
-				value += 1;
-			}, 25, 10);
-
-			Timer.wait(() => {
-				repeated.stop();
-			}, 125);
-
-			Timer.wait(() => {
-				chai.assert.ok(value < 10);
-
-				done();
-			}, 500);
-		});
-	});
-});
-
-describe('Timer, Waited', function () {
-	describe('Constructor', function () {
-		it('should create a proper waited timer', function () {
-			chai.assert.ok(new Waited(() => {}, 0));
-		});
-	
-		it('should handle bad parameters', function () {
-			chai.assert.throws(function () { new Waited(null, null); }, /callback/);
-			chai.assert.throws(function () { new Waited(() => {}, null); }, /time/);
-		});
-	});
-});
-
-describe('Timer, Repeated & Waited', function () {
-	describe('Methods', function () {
-		it('should be able to start', function (done) {
-			(new Waited(() => {
-				done();
-			}, 125)).start();
-		});
-	
-		it('should be able to stop', function (done) {
-			let value = 0;
-	
-			const waited = new Waited(() => {
-				value = 1234;
-			}, 125);
-	
-			Timer.wait(() => {
-				waited.stop();
-			}, 250);
-	
-			Timer.wait(() => {
-				chai.assert.equal(value, 0);
-	
-				done();
-			}, 375);
-		});
-	
-		it('should be able to restart', function (done) {
-			let value = 0;
-	
-			const waited = new Waited(() => {
-				value += 1;
-			}, 125);
-	
-			waited.start();
-	
-			Timer.wait(() => {
-				waited.restart();
-			}, 250);
-	
-			Timer.wait(() => {
-				chai.assert.equal(value, 2);
-	
-				done();
-			}, 500);
-		});
-	});
-});

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-	"compilerOptions": {
-		"allowSyntheticDefaultImports": true,
-		"declaration": true,
-		"forceConsistentCasingInFileNames": true,
-		"lib": [
-			"DOM",
-			"DOM.Iterable",
-			"ES2020"
-		],
-		"newLine": "lf",
-		"noEmitOnError": true,
-		"noFallthroughCasesInSwitch": true,
-		"noImplicitOverride": true,
-		"noImplicitReturns": true,
-		"noPropertyAccessFromIndexSignature": true,
-		"noUncheckedIndexedAccess": true,
-		"noUnusedLocals": true,
-		"noUnusedParameters": true,
-		"preserveConstEnums": true,
-		"pretty": true,
-		"resolveJsonModule": false,
-		"skipLibCheck": true,
-		"strict": true,
-		"stripInternal": true,
-		"target": "ES2020",
-		"useDefineForClassFields": true
-	},
-	"include": ["src/**/*.ts"],
-	"exclude": ["src/**/*.d.ts", "dist", "node_modules"]
-}