@pluv/crdt 0.16.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,18 @@
+
+> @pluv/crdt@0.16.0 build /home/runner/work/pluv/pluv/packages/crdt
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.0.2
+CLI Target: es6
+ESM Build start
+CJS Build start
+CJS dist/index.js 2.54 KB
+CJS ⚡️ Build success in 28ms
+ESM dist/index.mjs 1.34 KB
+ESM ⚡️ Build success in 29ms
+DTS Build start
+DTS ⚡️ Build success in 577ms
+DTS dist/index.d.mts 3.31 KB
+DTS dist/index.d.ts  3.31 KB

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @pluv/crdt
+
+## 0.16.0
+
+### Patch Changes
+
+- @pluv/types@0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,76 @@
+import { Json } from '@pluv/types';
+
+type InferCrdtStorageJson<T extends unknown> = T extends AbstractCrdtType<any, infer ICrdtJson> ? InferCrdtStorageJson<ICrdtJson> : T extends Record<string, any> ? {
+    [P in keyof T]: InferCrdtStorageJson<T[P]>;
+} : T extends (infer IArrayCrdtItem)[] ? InferCrdtStorageJson<IArrayCrdtItem>[] : T extends readonly (infer IReadonlyArrayCrdtItem)[] ? InferCrdtStorageJson<IReadonlyArrayCrdtItem> : T extends Json ? T : string;
+
+declare abstract class AbstractCrdtType<TValue extends unknown, TJson extends unknown> {
+    abstract value: TValue;
+    abstract toJson(): InferCrdtStorageJson<TJson>;
+}
+
+interface DocApplyEncodedStateParams {
+    origin?: string;
+    update?: string | Uint8Array;
+}
+interface DocSubscribeCallbackParams<T extends Record<string, AbstractCrdtType<any, any>>> {
+    doc: AbstractCrdtDoc<T>;
+    local: boolean;
+    origin?: string | null;
+    update: string;
+}
+declare abstract class AbstractCrdtDoc<T extends Record<string, AbstractCrdtType<any, any>>> {
+    abstract applyEncodedState(params: DocApplyEncodedStateParams): this;
+    abstract batchApplyEncodedState(updates: readonly (DocApplyEncodedStateParams | string | null | undefined)[]): this;
+    abstract canRedo(): boolean;
+    abstract canUndo(): boolean;
+    abstract destroy(): void;
+    abstract get(key?: undefined): T;
+    abstract get<TKey extends keyof T>(key: TKey): T[TKey];
+    abstract getEncodedState(): string;
+    abstract isEmpty(): boolean;
+    abstract redo(): this;
+    abstract subscribe(listener: (params: DocSubscribeCallbackParams<T>) => void): () => void;
+    abstract toJson(): InferCrdtStorageJson<T>;
+    abstract track(): this;
+    abstract transact(fn: () => void, origin?: string): this;
+    abstract undo(): this;
+}
+
+declare abstract class AbstractCrdtDocFactory<TStorage extends Record<string, AbstractCrdtType<any, any>>> {
+    abstract getEmpty(): AbstractCrdtDoc<TStorage>;
+    abstract getFactory(initialStorage?: () => TStorage): AbstractCrdtDocFactory<TStorage>;
+    abstract getFresh(): AbstractCrdtDoc<TStorage>;
+    abstract getInitialized(initialStorage?: () => TStorage): AbstractCrdtDoc<TStorage>;
+}
+
+declare class NoopCrdtDoc extends AbstractCrdtDoc<any> {
+    applyEncodedState(params: DocApplyEncodedStateParams): this;
+    batchApplyEncodedState(updates: readonly (string | DocApplyEncodedStateParams | null | undefined)[]): this;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    destroy(): void;
+    get(key?: undefined): {};
+    get<TKey extends never>(key: TKey): {}[TKey];
+    getEncodedState(): string;
+    isEmpty(): boolean;
+    redo(): this;
+    subscribe(listener: (params: DocSubscribeCallbackParams<{}>) => void): () => void;
+    toJson(): {};
+    track(): this;
+    transact(fn: () => void, origin?: string | undefined): this;
+    undo(): this;
+}
+
+declare class NoopCrdtDocFactory extends AbstractCrdtDocFactory<any> {
+    getEmpty(): NoopCrdtDoc;
+    getFactory(initialStorage?: (() => {}) | undefined): NoopCrdtDocFactory;
+    getFresh(): NoopCrdtDoc;
+    getInitialized(initialStorage?: (() => {}) | undefined): NoopCrdtDoc;
+}
+
+declare const noop: {
+    doc: (args?: any) => NoopCrdtDocFactory;
+};
+
+export { AbstractCrdtDoc, AbstractCrdtDocFactory, AbstractCrdtType, type DocApplyEncodedStateParams, type DocSubscribeCallbackParams, type InferCrdtStorageJson, NoopCrdtDoc, NoopCrdtDocFactory, noop };

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { Json } from '@pluv/types';
+
+type InferCrdtStorageJson<T extends unknown> = T extends AbstractCrdtType<any, infer ICrdtJson> ? InferCrdtStorageJson<ICrdtJson> : T extends Record<string, any> ? {
+    [P in keyof T]: InferCrdtStorageJson<T[P]>;
+} : T extends (infer IArrayCrdtItem)[] ? InferCrdtStorageJson<IArrayCrdtItem>[] : T extends readonly (infer IReadonlyArrayCrdtItem)[] ? InferCrdtStorageJson<IReadonlyArrayCrdtItem> : T extends Json ? T : string;
+
+declare abstract class AbstractCrdtType<TValue extends unknown, TJson extends unknown> {
+    abstract value: TValue;
+    abstract toJson(): InferCrdtStorageJson<TJson>;
+}
+
+interface DocApplyEncodedStateParams {
+    origin?: string;
+    update?: string | Uint8Array;
+}
+interface DocSubscribeCallbackParams<T extends Record<string, AbstractCrdtType<any, any>>> {
+    doc: AbstractCrdtDoc<T>;
+    local: boolean;
+    origin?: string | null;
+    update: string;
+}
+declare abstract class AbstractCrdtDoc<T extends Record<string, AbstractCrdtType<any, any>>> {
+    abstract applyEncodedState(params: DocApplyEncodedStateParams): this;
+    abstract batchApplyEncodedState(updates: readonly (DocApplyEncodedStateParams | string | null | undefined)[]): this;
+    abstract canRedo(): boolean;
+    abstract canUndo(): boolean;
+    abstract destroy(): void;
+    abstract get(key?: undefined): T;
+    abstract get<TKey extends keyof T>(key: TKey): T[TKey];
+    abstract getEncodedState(): string;
+    abstract isEmpty(): boolean;
+    abstract redo(): this;
+    abstract subscribe(listener: (params: DocSubscribeCallbackParams<T>) => void): () => void;
+    abstract toJson(): InferCrdtStorageJson<T>;
+    abstract track(): this;
+    abstract transact(fn: () => void, origin?: string): this;
+    abstract undo(): this;
+}
+
+declare abstract class AbstractCrdtDocFactory<TStorage extends Record<string, AbstractCrdtType<any, any>>> {
+    abstract getEmpty(): AbstractCrdtDoc<TStorage>;
+    abstract getFactory(initialStorage?: () => TStorage): AbstractCrdtDocFactory<TStorage>;
+    abstract getFresh(): AbstractCrdtDoc<TStorage>;
+    abstract getInitialized(initialStorage?: () => TStorage): AbstractCrdtDoc<TStorage>;
+}
+
+declare class NoopCrdtDoc extends AbstractCrdtDoc<any> {
+    applyEncodedState(params: DocApplyEncodedStateParams): this;
+    batchApplyEncodedState(updates: readonly (string | DocApplyEncodedStateParams | null | undefined)[]): this;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    destroy(): void;
+    get(key?: undefined): {};
+    get<TKey extends never>(key: TKey): {}[TKey];
+    getEncodedState(): string;
+    isEmpty(): boolean;
+    redo(): this;
+    subscribe(listener: (params: DocSubscribeCallbackParams<{}>) => void): () => void;
+    toJson(): {};
+    track(): this;
+    transact(fn: () => void, origin?: string | undefined): this;
+    undo(): this;
+}
+
+declare class NoopCrdtDocFactory extends AbstractCrdtDocFactory<any> {
+    getEmpty(): NoopCrdtDoc;
+    getFactory(initialStorage?: (() => {}) | undefined): NoopCrdtDocFactory;
+    getFresh(): NoopCrdtDoc;
+    getInitialized(initialStorage?: (() => {}) | undefined): NoopCrdtDoc;
+}
+
+declare const noop: {
+    doc: (args?: any) => NoopCrdtDocFactory;
+};
+
+export { AbstractCrdtDoc, AbstractCrdtDocFactory, AbstractCrdtType, type DocApplyEncodedStateParams, type DocSubscribeCallbackParams, type InferCrdtStorageJson, NoopCrdtDoc, NoopCrdtDocFactory, noop };

package/dist/index.js

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbstractCrdtDoc: () => AbstractCrdtDoc,
+  AbstractCrdtDocFactory: () => AbstractCrdtDocFactory,
+  AbstractCrdtType: () => AbstractCrdtType,
+  NoopCrdtDoc: () => NoopCrdtDoc,
+  NoopCrdtDocFactory: () => NoopCrdtDocFactory,
+  noop: () => noop
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AbstractCrdtDoc.ts
+var AbstractCrdtDoc = class {
+};
+
+// src/AbstractCrdtDocFactory.ts
+var AbstractCrdtDocFactory = class {
+};
+
+// src/AbstractCrdtType.ts
+var AbstractCrdtType = class {
+};
+
+// src/NoopCrdtDoc.ts
+var NoopCrdtDoc = class extends AbstractCrdtDoc {
+  applyEncodedState(params) {
+    return this;
+  }
+  batchApplyEncodedState(updates) {
+    return this;
+  }
+  canRedo() {
+    return false;
+  }
+  canUndo() {
+    return false;
+  }
+  destroy() {
+    return;
+  }
+  get(key) {
+    return typeof key === "string" ? void 0 : {};
+  }
+  getEncodedState() {
+    return "";
+  }
+  isEmpty() {
+    return true;
+  }
+  redo() {
+    return this;
+  }
+  subscribe(listener) {
+    return () => void 0;
+  }
+  toJson() {
+    return {};
+  }
+  track() {
+    return this;
+  }
+  transact(fn, origin) {
+    fn();
+    return this;
+  }
+  undo() {
+    return this;
+  }
+};
+
+// src/NoopCrdtDocFactory.ts
+var NoopCrdtDocFactory = class extends AbstractCrdtDocFactory {
+  getEmpty() {
+    return new NoopCrdtDoc();
+  }
+  getFactory(initialStorage) {
+    return this;
+  }
+  getFresh() {
+    return new NoopCrdtDoc();
+  }
+  getInitialized(initialStorage) {
+    return new NoopCrdtDoc();
+  }
+};
+
+// src/noop.ts
+var noop = {
+  doc: (args) => new NoopCrdtDocFactory()
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractCrdtDoc,
+  AbstractCrdtDocFactory,
+  AbstractCrdtType,
+  NoopCrdtDoc,
+  NoopCrdtDocFactory,
+  noop
+});

package/dist/index.mjs

@@ -0,0 +1,87 @@
+// src/AbstractCrdtDoc.ts
+var AbstractCrdtDoc = class {
+};
+
+// src/AbstractCrdtDocFactory.ts
+var AbstractCrdtDocFactory = class {
+};
+
+// src/AbstractCrdtType.ts
+var AbstractCrdtType = class {
+};
+
+// src/NoopCrdtDoc.ts
+var NoopCrdtDoc = class extends AbstractCrdtDoc {
+  applyEncodedState(params) {
+    return this;
+  }
+  batchApplyEncodedState(updates) {
+    return this;
+  }
+  canRedo() {
+    return false;
+  }
+  canUndo() {
+    return false;
+  }
+  destroy() {
+    return;
+  }
+  get(key) {
+    return typeof key === "string" ? void 0 : {};
+  }
+  getEncodedState() {
+    return "";
+  }
+  isEmpty() {
+    return true;
+  }
+  redo() {
+    return this;
+  }
+  subscribe(listener) {
+    return () => void 0;
+  }
+  toJson() {
+    return {};
+  }
+  track() {
+    return this;
+  }
+  transact(fn, origin) {
+    fn();
+    return this;
+  }
+  undo() {
+    return this;
+  }
+};
+
+// src/NoopCrdtDocFactory.ts
+var NoopCrdtDocFactory = class extends AbstractCrdtDocFactory {
+  getEmpty() {
+    return new NoopCrdtDoc();
+  }
+  getFactory(initialStorage) {
+    return this;
+  }
+  getFresh() {
+    return new NoopCrdtDoc();
+  }
+  getInitialized(initialStorage) {
+    return new NoopCrdtDoc();
+  }
+};
+
+// src/noop.ts
+var noop = {
+  doc: (args) => new NoopCrdtDocFactory()
+};
+export {
+  AbstractCrdtDoc,
+  AbstractCrdtDocFactory,
+  AbstractCrdtType,
+  NoopCrdtDoc,
+  NoopCrdtDocFactory,
+  noop
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@pluv/crdt",
+  "version": "0.16.0",
+  "description": "crdt base for @pluv/io",
+  "author": "leedavidcs",
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/crdt"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pluv/types": "^0.16.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.56.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "@pluv/tsconfig": "^0.16.0",
+    "eslint-config-pluv": "^0.16.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/AbstractCrdtDoc.ts

@@ -0,0 +1,45 @@
+import { AbstractCrdtType } from "./AbstractCrdtType";
+import type { InferCrdtStorageJson } from "./types";
+
+export interface DocApplyEncodedStateParams {
+    origin?: string;
+    update?: string | Uint8Array;
+}
+
+export interface DocSubscribeCallbackParams<
+    T extends Record<string, AbstractCrdtType<any, any>>,
+> {
+    doc: AbstractCrdtDoc<T>;
+    local: boolean;
+    origin?: string | null;
+    update: string;
+}
+
+export abstract class AbstractCrdtDoc<
+    T extends Record<string, AbstractCrdtType<any, any>>,
+> {
+    public abstract applyEncodedState(params: DocApplyEncodedStateParams): this;
+    public abstract batchApplyEncodedState(
+        updates: readonly (
+            | DocApplyEncodedStateParams
+            | string
+            | null
+            | undefined
+        )[],
+    ): this;
+    public abstract canRedo(): boolean;
+    public abstract canUndo(): boolean;
+    public abstract destroy(): void;
+    public abstract get(key?: undefined): T;
+    public abstract get<TKey extends keyof T>(key: TKey): T[TKey];
+    public abstract getEncodedState(): string;
+    public abstract isEmpty(): boolean;
+    public abstract redo(): this;
+    public abstract subscribe(
+        listener: (params: DocSubscribeCallbackParams<T>) => void,
+    ): () => void;
+    public abstract toJson(): InferCrdtStorageJson<T>;
+    public abstract track(): this;
+    public abstract transact(fn: () => void, origin?: string): this;
+    public abstract undo(): this;
+}

package/src/AbstractCrdtDocFactory.ts

@@ -0,0 +1,15 @@
+import { AbstractCrdtDoc } from "./AbstractCrdtDoc";
+import type { AbstractCrdtType } from "./AbstractCrdtType";
+
+export abstract class AbstractCrdtDocFactory<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> {
+    public abstract getEmpty(): AbstractCrdtDoc<TStorage>;
+    public abstract getFactory(
+        initialStorage?: () => TStorage,
+    ): AbstractCrdtDocFactory<TStorage>;
+    public abstract getFresh(): AbstractCrdtDoc<TStorage>;
+    public abstract getInitialized(
+        initialStorage?: () => TStorage,
+    ): AbstractCrdtDoc<TStorage>;
+}

package/src/AbstractCrdtType.ts

@@ -0,0 +1,10 @@
+import type { InferCrdtStorageJson } from "./types";
+
+export abstract class AbstractCrdtType<
+    TValue extends unknown,
+    TJson extends unknown,
+> {
+    public abstract value: TValue;
+
+    public abstract toJson(): InferCrdtStorageJson<TJson>;
+}

package/src/NoopCrdtDoc.ts

@@ -0,0 +1,76 @@
+import type {
+    DocApplyEncodedStateParams,
+    DocSubscribeCallbackParams,
+} from "./AbstractCrdtDoc";
+import { AbstractCrdtDoc } from "./AbstractCrdtDoc";
+
+export class NoopCrdtDoc extends AbstractCrdtDoc<any> {
+    public applyEncodedState(params: DocApplyEncodedStateParams): this {
+        return this;
+    }
+
+    public batchApplyEncodedState(
+        updates: readonly (
+            | string
+            | DocApplyEncodedStateParams
+            | null
+            | undefined
+        )[],
+    ): this {
+        return this;
+    }
+
+    public canRedo(): boolean {
+        return false;
+    }
+
+    public canUndo(): boolean {
+        return false;
+    }
+
+    public destroy(): void {
+        return;
+    }
+
+    public get(key?: undefined): {};
+    public get<TKey extends never>(key: TKey): {}[TKey];
+    public get(key?: string): {} | undefined {
+        return typeof key === "string" ? undefined : {};
+    }
+
+    public getEncodedState(): string {
+        return "";
+    }
+
+    public isEmpty(): boolean {
+        return true;
+    }
+
+    public redo(): this {
+        return this;
+    }
+
+    public subscribe(
+        listener: (params: DocSubscribeCallbackParams<{}>) => void,
+    ): () => void {
+        return () => undefined;
+    }
+
+    public toJson(): {} {
+        return {};
+    }
+
+    public track(): this {
+        return this;
+    }
+
+    public transact(fn: () => void, origin?: string | undefined): this {
+        fn();
+
+        return this;
+    }
+
+    public undo(): this {
+        return this;
+    }
+}

package/src/NoopCrdtDocFactory.ts

@@ -0,0 +1,24 @@
+import { AbstractCrdtDocFactory } from "./AbstractCrdtDocFactory";
+import { NoopCrdtDoc } from "./NoopCrdtDoc";
+
+export class NoopCrdtDocFactory extends AbstractCrdtDocFactory<any> {
+    public getEmpty(): NoopCrdtDoc {
+        return new NoopCrdtDoc();
+    }
+
+    public getFactory(
+        initialStorage?: (() => {}) | undefined,
+    ): NoopCrdtDocFactory {
+        return this;
+    }
+
+    public getFresh(): NoopCrdtDoc {
+        return new NoopCrdtDoc();
+    }
+
+    public getInitialized(
+        initialStorage?: (() => {}) | undefined,
+    ): NoopCrdtDoc {
+        return new NoopCrdtDoc();
+    }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export { AbstractCrdtDoc } from "./AbstractCrdtDoc";
+export type {
+    DocApplyEncodedStateParams,
+    DocSubscribeCallbackParams,
+} from "./AbstractCrdtDoc";
+export { AbstractCrdtDocFactory } from "./AbstractCrdtDocFactory";
+export { AbstractCrdtType } from "./AbstractCrdtType";
+export { NoopCrdtDoc } from "./NoopCrdtDoc";
+export { NoopCrdtDocFactory } from "./NoopCrdtDocFactory";
+export { noop } from "./noop";
+export type { InferCrdtStorageJson } from "./types";

package/src/noop.ts

@@ -0,0 +1,5 @@
+import { NoopCrdtDocFactory } from "./NoopCrdtDocFactory";
+
+export const noop = {
+    doc: (args?: any) => new NoopCrdtDocFactory(),
+};

package/src/types.ts

@@ -0,0 +1,15 @@
+import type { Json } from "@pluv/types";
+import type { AbstractCrdtType } from "./AbstractCrdtType";
+
+export type InferCrdtStorageJson<T extends unknown> =
+    T extends AbstractCrdtType<any, infer ICrdtJson>
+        ? InferCrdtStorageJson<ICrdtJson>
+        : T extends Record<string, any>
+          ? { [P in keyof T]: InferCrdtStorageJson<T[P]> }
+          : T extends (infer IArrayCrdtItem)[]
+            ? InferCrdtStorageJson<IArrayCrdtItem>[]
+            : T extends readonly (infer IReadonlyArrayCrdtItem)[]
+              ? InferCrdtStorageJson<IReadonlyArrayCrdtItem>
+              : T extends Json
+                ? T
+                : string;

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@pluv/tsconfig/library.json",
+	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"lib": ["esnext"]
+	}
+}