@botpress/cli 2.1.1 → 2.1.2

package/dist/utils/cache-utils.js

@@ -0,0 +1,104 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_utils_exports = {};
+__export(cache_utils_exports, {
+  FSKeyValueCache: () => FSKeyValueCache
+});
+module.exports = __toCommonJS(cache_utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+class FSKeyValueCache {
+  constructor(_filepath) {
+    this._filepath = _filepath;
+  }
+  _initialized = false;
+  async init() {
+    if (this._initialized) {
+      return;
+    }
+    const dirname = import_path.default.dirname(this._filepath);
+    if (!import_fs.default.existsSync(dirname)) {
+      await import_fs.default.promises.mkdir(dirname, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(this._filepath)) {
+      await this._writeJSON(this._filepath, {});
+    }
+    this._initialized = true;
+  }
+  async sync(key, value, prompt) {
+    await this.init();
+    if (value) {
+      await this.set(key, value);
+      return value;
+    }
+    const data = await this.get(key);
+    const newValue = await prompt(data);
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async has(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    return data[key] !== void 0;
+  }
+  async get(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    return data[key];
+  }
+  async set(key, value) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    data[key] = value;
+    return this._writeJSON(this._filepath, data);
+  }
+  async rm(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    delete data[key];
+    return this._writeJSON(this._filepath, data);
+  }
+  async clear() {
+    await this.init();
+    return this._writeJSON(this._filepath, {});
+  }
+  _writeJSON = (filepath, data) => {
+    const fileContent = JSON.stringify(data, null, 2);
+    return import_fs.default.promises.writeFile(filepath, fileContent);
+  };
+  _readJSON = async (filepath) => {
+    const fileContent = await import_fs.default.promises.readFile(filepath, "utf8");
+    return JSON.parse(fileContent);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FSKeyValueCache
+});
+//# sourceMappingURL=cache-utils.js.map

package/dist/utils/cache-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/cache-utils.ts"],
+  "sourcesContent": ["import fs from 'fs'\nimport pathlib from 'path'\n\nexport class FSKeyValueCache<T extends Object> {\n  private _initialized = false\n\n  public constructor(private _filepath: string) {}\n\n  public async init(): Promise<void> {\n    if (this._initialized) {\n      return\n    }\n    const dirname = pathlib.dirname(this._filepath)\n    if (!fs.existsSync(dirname)) {\n      await fs.promises.mkdir(dirname, { recursive: true })\n    }\n    if (!fs.existsSync(this._filepath)) {\n      await this._writeJSON(this._filepath, {})\n    }\n    this._initialized = true\n  }\n\n  public async sync<K extends keyof T>(\n    key: K,\n    value: T[K] | undefined,\n    prompt: (initial?: T[K]) => Promise<T[K]>\n  ): Promise<T[K]> {\n    await this.init()\n    if (value) {\n      await this.set(key, value)\n      return value\n    }\n    const data = await this.get(key)\n    const newValue = await prompt(data)\n    await this.set(key, newValue)\n    return newValue\n  }\n\n  public async has<K extends keyof T>(key: K): Promise<boolean> {\n    await this.init()\n    const data = await this._readJSON(this._filepath)\n    return data[key] !== undefined\n  }\n\n  public async get<K extends keyof T>(key: K): Promise<T[K] | undefined> {\n    await this.init()\n    const data: T = await this._readJSON(this._filepath)\n    return data[key]\n  }\n\n  public async set<K extends keyof T>(key: K, value: T[K]): Promise<void> {\n    await this.init()\n    const data: T = await this._readJSON(this._filepath)\n    data[key] = value\n    return this._writeJSON(this._filepath, data)\n  }\n\n  public async rm<K extends keyof T>(key: K): Promise<void> {\n    await this.init()\n    const data: T = await this._readJSON(this._filepath)\n    delete data[key]\n    return this._writeJSON(this._filepath, data)\n  }\n\n  public async clear(): Promise<void> {\n    await this.init()\n    return this._writeJSON(this._filepath, {})\n  }\n\n  private _writeJSON = (filepath: string, data: any) => {\n    const fileContent = JSON.stringify(data, null, 2)\n    return fs.promises.writeFile(filepath, fileContent)\n  }\n\n  private _readJSON = async (filepath: string) => {\n    const fileContent = await fs.promises.readFile(filepath, 'utf8')\n    return JSON.parse(fileContent)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAe;AACf,kBAAoB;AAEb,MAAM,gBAAkC;AAAA,EAGtC,YAAoB,WAAmB;AAAnB;AAAA,EAAoB;AAAA,EAFvC,eAAe;AAAA,EAIvB,MAAa,OAAsB;AACjC,QAAI,KAAK,cAAc;AACrB;AAAA,IACF;AACA,UAAM,UAAU,YAAAA,QAAQ,QAAQ,KAAK,SAAS;AAC9C,QAAI,CAAC,UAAAC,QAAG,WAAW,OAAO,GAAG;AAC3B,YAAM,UAAAA,QAAG,SAAS,MAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,IACtD;AACA,QAAI,CAAC,UAAAA,QAAG,WAAW,KAAK,SAAS,GAAG;AAClC,YAAM,KAAK,WAAW,KAAK,WAAW,CAAC,CAAC;AAAA,IAC1C;AACA,SAAK,eAAe;AAAA,EACtB;AAAA,EAEA,MAAa,KACX,KACA,OACA,QACe;AACf,UAAM,KAAK,KAAK;AAChB,QAAI,OAAO;AACT,YAAM,KAAK,IAAI,KAAK,KAAK;AACzB,aAAO;AAAA,IACT;AACA,UAAM,OAAO,MAAM,KAAK,IAAI,GAAG;AAC/B,UAAM,WAAW,MAAM,OAAO,IAAI;AAClC,UAAM,KAAK,IAAI,KAAK,QAAQ;AAC5B,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,IAAuB,KAA0B;AAC5D,UAAM,KAAK,KAAK;AAChB,UAAM,OAAO,MAAM,KAAK,UAAU,KAAK,SAAS;AAChD,WAAO,KAAK,GAAG,MAAM;AAAA,EACvB;AAAA,EAEA,MAAa,IAAuB,KAAmC;AACrE,UAAM,KAAK,KAAK;AAChB,UAAM,OAAU,MAAM,KAAK,UAAU,KAAK,SAAS;AACnD,WAAO,KAAK,GAAG;AAAA,EACjB;AAAA,EAEA,MAAa,IAAuB,KAAQ,OAA4B;AACtE,UAAM,KAAK,KAAK;AAChB,UAAM,OAAU,MAAM,KAAK,UAAU,KAAK,SAAS;AACnD,SAAK,GAAG,IAAI;AACZ,WAAO,KAAK,WAAW,KAAK,WAAW,IAAI;AAAA,EAC7C;AAAA,EAEA,MAAa,GAAsB,KAAuB;AACxD,UAAM,KAAK,KAAK;AAChB,UAAM,OAAU,MAAM,KAAK,UAAU,KAAK,SAAS;AACnD,WAAO,KAAK,GAAG;AACf,WAAO,KAAK,WAAW,KAAK,WAAW,IAAI;AAAA,EAC7C;AAAA,EAEA,MAAa,QAAuB;AAClC,UAAM,KAAK,KAAK;AAChB,WAAO,KAAK,WAAW,KAAK,WAAW,CAAC,CAAC;AAAA,EAC3C;AAAA,EAEQ,aAAa,CAAC,UAAkB,SAAc;AACpD,UAAM,cAAc,KAAK,UAAU,MAAM,MAAM,CAAC;AAChD,WAAO,UAAAA,QAAG,SAAS,UAAU,UAAU,WAAW;AAAA,EACpD;AAAA,EAEQ,YAAY,OAAO,aAAqB;AAC9C,UAAM,cAAc,MAAM,UAAAA,QAAG,SAAS,SAAS,UAAU,MAAM;AAC/D,WAAO,KAAK,MAAM,WAAW;AAAA,EAC/B;AACF;",
+  "names": ["pathlib", "fs"]
+}

package/dist/utils/case-utils.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var case_utils_exports = {};
+__export(case_utils_exports, {
+  is: () => is,
+  to: () => to
+});
+module.exports = __toCommonJS(case_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+const specialChars = /[^a-zA-Z0-9_-]/g;
+const capitalizeFirstLetter = (text) => text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+const splitChar = (char) => (tokens) => tokens.flatMap((token) => token.split(char));
+const splitRegex = (regex) => (tokens) => tokens.flatMap((token) => token.split(regex));
+const splitCaseChange = (tokens) => tokens.flatMap((token) => token.split(/(?<=[a-z])(?=[A-Z])/));
+const splitTokens = (tokens) => {
+  return [splitRegex(specialChars), splitChar("-"), splitChar("_"), splitCaseChange].reduce(
+    (acc, step) => step(acc),
+    tokens
+  );
+};
+const filterOutEmpty = (tokens) => tokens.filter((token) => token.length > 0);
+const filterOutRegex = (regex) => (tokens) => tokens.filter((token) => !regex.test(token));
+const filterTokens = (tokens) => {
+  return [filterOutEmpty, filterOutRegex(specialChars)].reduce((acc, step) => step(acc), tokens);
+};
+const fromTokens = {
+  pascalCase: (tokens) => {
+    return tokens.map(capitalizeFirstLetter).join("");
+  },
+  kebabCase: (tokens) => {
+    return tokens.map((token) => token.toLowerCase()).join("-");
+  },
+  snakeCase: (tokens) => {
+    return tokens.map((token) => token.toLowerCase()).join("_");
+  },
+  screamingSnakeCase: (tokens) => {
+    return tokens.map((token) => token.toUpperCase()).join("_");
+  },
+  camelCase: (tokens) => {
+    const [first, ...others] = tokens;
+    return [first.toLowerCase(), ...others.map(capitalizeFirstLetter)].join("");
+  }
+};
+const to = import_lodash.default.mapValues(fromTokens, (fn) => (text) => {
+  let tokens = splitTokens([text]);
+  tokens = filterTokens(tokens);
+  return fn(tokens);
+});
+const is = import_lodash.default.mapValues(to, (fn) => (text) => {
+  const result = fn(text);
+  return result === text;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  is,
+  to
+});
+//# sourceMappingURL=case-utils.js.map

package/dist/utils/case-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/case-utils.ts"],
+  "sourcesContent": ["import _ from 'lodash'\n\nconst specialChars = /[^a-zA-Z0-9_-]/g\n\nconst capitalizeFirstLetter = (text: string) => text.charAt(0).toUpperCase() + text.slice(1).toLowerCase()\n\nconst splitChar = (char: string) => (tokens: string[]) => tokens.flatMap((token) => token.split(char))\nconst splitRegex = (regex: RegExp) => (tokens: string[]) => tokens.flatMap((token) => token.split(regex))\nconst splitCaseChange = (tokens: string[]) => tokens.flatMap((token) => token.split(/(?<=[a-z])(?=[A-Z])/))\nconst splitTokens = (tokens: string[]) => {\n  return [splitRegex(specialChars), splitChar('-'), splitChar('_'), splitCaseChange].reduce(\n    (acc, step) => step(acc),\n    tokens\n  )\n}\n\nconst filterOutEmpty = (tokens: string[]) => tokens.filter((token) => token.length > 0)\nconst filterOutRegex = (regex: RegExp) => (tokens: string[]) => tokens.filter((token) => !regex.test(token))\nconst filterTokens = (tokens: string[]) => {\n  return [filterOutEmpty, filterOutRegex(specialChars)].reduce((acc, step) => step(acc), tokens)\n}\n\ntype SupportedCase = `${'pascal' | 'kebab' | 'snake' | 'screamingSnake' | 'camel'}Case`\n\nconst fromTokens = {\n  pascalCase: (tokens: string[]) => {\n    return tokens.map(capitalizeFirstLetter).join('')\n  },\n  kebabCase: (tokens: string[]) => {\n    return tokens.map((token) => token.toLowerCase()).join('-')\n  },\n  snakeCase: (tokens: string[]) => {\n    return tokens.map((token) => token.toLowerCase()).join('_')\n  },\n  screamingSnakeCase: (tokens: string[]) => {\n    return tokens.map((token) => token.toUpperCase()).join('_')\n  },\n  camelCase: (tokens: string[]) => {\n    const [first, ...others] = tokens\n    return [first!.toLowerCase(), ...others.map(capitalizeFirstLetter)].join('')\n  },\n} as Record<SupportedCase, (tokens: string[]) => string>\n\nexport const to = _.mapValues(fromTokens, (fn) => (text: string) => {\n  let tokens = splitTokens([text])\n  tokens = filterTokens(tokens)\n  return fn(tokens)\n}) satisfies Record<SupportedCase, (text: string) => string>\n\nexport const is = _.mapValues(to, (fn) => (text: string) => {\n  const result = fn(text)\n  return result === text\n}) satisfies Record<SupportedCase, (text: string) => boolean>\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AAEd,MAAM,eAAe;AAErB,MAAM,wBAAwB,CAAC,SAAiB,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC,EAAE,YAAY;AAEzG,MAAM,YAAY,CAAC,SAAiB,CAAC,WAAqB,OAAO,QAAQ,CAAC,UAAU,MAAM,MAAM,IAAI,CAAC;AACrG,MAAM,aAAa,CAAC,UAAkB,CAAC,WAAqB,OAAO,QAAQ,CAAC,UAAU,MAAM,MAAM,KAAK,CAAC;AACxG,MAAM,kBAAkB,CAAC,WAAqB,OAAO,QAAQ,CAAC,UAAU,MAAM,MAAM,qBAAqB,CAAC;AAC1G,MAAM,cAAc,CAAC,WAAqB;AACxC,SAAO,CAAC,WAAW,YAAY,GAAG,UAAU,GAAG,GAAG,UAAU,GAAG,GAAG,eAAe,EAAE;AAAA,IACjF,CAAC,KAAK,SAAS,KAAK,GAAG;AAAA,IACvB;AAAA,EACF;AACF;AAEA,MAAM,iBAAiB,CAAC,WAAqB,OAAO,OAAO,CAAC,UAAU,MAAM,SAAS,CAAC;AACtF,MAAM,iBAAiB,CAAC,UAAkB,CAAC,WAAqB,OAAO,OAAO,CAAC,UAAU,CAAC,MAAM,KAAK,KAAK,CAAC;AAC3G,MAAM,eAAe,CAAC,WAAqB;AACzC,SAAO,CAAC,gBAAgB,eAAe,YAAY,CAAC,EAAE,OAAO,CAAC,KAAK,SAAS,KAAK,GAAG,GAAG,MAAM;AAC/F;AAIA,MAAM,aAAa;AAAA,EACjB,YAAY,CAAC,WAAqB;AAChC,WAAO,OAAO,IAAI,qBAAqB,EAAE,KAAK,EAAE;AAAA,EAClD;AAAA,EACA,WAAW,CAAC,WAAqB;AAC/B,WAAO,OAAO,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,KAAK,GAAG;AAAA,EAC5D;AAAA,EACA,WAAW,CAAC,WAAqB;AAC/B,WAAO,OAAO,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,KAAK,GAAG;AAAA,EAC5D;AAAA,EACA,oBAAoB,CAAC,WAAqB;AACxC,WAAO,OAAO,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,KAAK,GAAG;AAAA,EAC5D;AAAA,EACA,WAAW,CAAC,WAAqB;AAC/B,UAAM,CAAC,OAAO,GAAG,MAAM,IAAI;AAC3B,WAAO,CAAC,MAAO,YAAY,GAAG,GAAG,OAAO,IAAI,qBAAqB,CAAC,EAAE,KAAK,EAAE;AAAA,EAC7E;AACF;AAEO,MAAM,KAAK,cAAAA,QAAE,UAAU,YAAY,CAAC,OAAO,CAAC,SAAiB;AAClE,MAAI,SAAS,YAAY,CAAC,IAAI,CAAC;AAC/B,WAAS,aAAa,MAAM;AAC5B,SAAO,GAAG,MAAM;AAClB,CAAC;AAEM,MAAM,KAAK,cAAAA,QAAE,UAAU,IAAI,CAAC,OAAO,CAAC,SAAiB;AAC1D,QAAM,SAAS,GAAG,IAAI;AACtB,SAAO,WAAW;AACpB,CAAC;",
+  "names": ["_"]
+}

package/dist/utils/case-utils.test.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var caseUtils = __toESM(require("./case-utils"));
+const pascalCase = "HelloLittleWorld";
+const kebabCase = "hello-little-world";
+const snakeCase = "hello_little_world";
+const screamingSnakeCase = "HELLO_LITTLE_WORLD";
+const camelCase = "helloLittleWorld";
+(0, import_vitest.test)("case utils should convert from pascal case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(pascalCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(pascalCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(pascalCase)).toBe(screamingSnakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(pascalCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from kebab case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(kebabCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(kebabCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(kebabCase)).toBe(screamingSnakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(kebabCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from snake case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(snakeCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(snakeCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(snakeCase)).toBe(screamingSnakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(snakeCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from screaming snake case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(screamingSnakeCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(screamingSnakeCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(screamingSnakeCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(screamingSnakeCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from camel case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(camelCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(camelCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(camelCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(camelCase)).toBe(screamingSnakeCase);
+});
+(0, import_vitest.test)("case utils should split special characters when converting", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(`${pascalCase}.2`)).toBe(`${pascalCase}2`);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(`${kebabCase}.2`)).toBe(`${kebabCase}-2`);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(`${snakeCase}.2`)).toBe(`${snakeCase}_2`);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(`${screamingSnakeCase}_2`);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(`${camelCase}.2`)).toBe(`${camelCase}2`);
+});
+(0, import_vitest.test)("case utils should prevent special characters when checking", () => {
+  (0, import_vitest.expect)(caseUtils.is.pascalCase(`${pascalCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.kebabCase(`${kebabCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.snakeCase(`${snakeCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.camelCase(`${camelCase}.2`)).toBe(false);
+});
+//# sourceMappingURL=case-utils.test.js.map

package/dist/utils/case-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/case-utils.test.ts"],
+  "sourcesContent": ["import { test, expect } from 'vitest'\nimport * as caseUtils from './case-utils'\n\nconst pascalCase = 'HelloLittleWorld'\nconst kebabCase = 'hello-little-world'\nconst snakeCase = 'hello_little_world'\nconst screamingSnakeCase = 'HELLO_LITTLE_WORLD'\nconst camelCase = 'helloLittleWorld'\n\ntest('case utils should convert from pascal case to all other cases', () => {\n  expect(caseUtils.to.kebabCase(pascalCase)).toBe(kebabCase)\n  expect(caseUtils.to.snakeCase(pascalCase)).toBe(snakeCase)\n  expect(caseUtils.to.screamingSnakeCase(pascalCase)).toBe(screamingSnakeCase)\n  expect(caseUtils.to.camelCase(pascalCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from kebab case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(kebabCase)).toBe(pascalCase)\n  expect(caseUtils.to.snakeCase(kebabCase)).toBe(snakeCase)\n  expect(caseUtils.to.screamingSnakeCase(kebabCase)).toBe(screamingSnakeCase)\n  expect(caseUtils.to.camelCase(kebabCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from snake case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(snakeCase)).toBe(pascalCase)\n  expect(caseUtils.to.kebabCase(snakeCase)).toBe(kebabCase)\n  expect(caseUtils.to.screamingSnakeCase(snakeCase)).toBe(screamingSnakeCase)\n  expect(caseUtils.to.camelCase(snakeCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from screaming snake case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(screamingSnakeCase)).toBe(pascalCase)\n  expect(caseUtils.to.kebabCase(screamingSnakeCase)).toBe(kebabCase)\n  expect(caseUtils.to.snakeCase(screamingSnakeCase)).toBe(snakeCase)\n  expect(caseUtils.to.camelCase(screamingSnakeCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from camel case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(camelCase)).toBe(pascalCase)\n  expect(caseUtils.to.kebabCase(camelCase)).toBe(kebabCase)\n  expect(caseUtils.to.snakeCase(camelCase)).toBe(snakeCase)\n  expect(caseUtils.to.screamingSnakeCase(camelCase)).toBe(screamingSnakeCase)\n})\n\ntest('case utils should split special characters when converting', () => {\n  expect(caseUtils.to.pascalCase(`${pascalCase}.2`)).toBe(`${pascalCase}2`)\n  expect(caseUtils.to.kebabCase(`${kebabCase}.2`)).toBe(`${kebabCase}-2`)\n  expect(caseUtils.to.snakeCase(`${snakeCase}.2`)).toBe(`${snakeCase}_2`)\n  expect(caseUtils.to.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(`${screamingSnakeCase}_2`)\n  expect(caseUtils.to.camelCase(`${camelCase}.2`)).toBe(`${camelCase}2`)\n})\n\ntest('case utils should prevent special characters when checking', () => {\n  expect(caseUtils.is.pascalCase(`${pascalCase}.2`)).toBe(false)\n  expect(caseUtils.is.kebabCase(`${kebabCase}.2`)).toBe(false)\n  expect(caseUtils.is.snakeCase(`${snakeCase}.2`)).toBe(false)\n  expect(caseUtils.is.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(false)\n  expect(caseUtils.is.camelCase(`${camelCase}.2`)).toBe(false)\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/utils/esbuild-utils.js

@@ -0,0 +1,92 @@
+"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);
+var esbuild_utils_exports = {};
+__export(esbuild_utils_exports, {
+  buildCode: () => buildCode,
+  buildEntrypoint: () => buildEntrypoint
+});
+module.exports = __toCommonJS(esbuild_utils_exports);
+var import_esbuild = require("esbuild");
+const keepNames = true;
+function buildCode({
+  cwd,
+  minify = true,
+  bundle = true,
+  sourcemap = false,
+  logLevel = "silent",
+  outfile,
+  code,
+  write,
+  platform = "node"
+}) {
+  return (0, import_esbuild.build)({
+    stdin: {
+      contents: code,
+      resolveDir: cwd,
+      loader: "ts"
+    },
+    logOverride: {
+      "equals-negative-zero": "silent"
+    },
+    platform,
+    target: "es2020",
+    sourcemap,
+    minify,
+    bundle,
+    outfile,
+    absWorkingDir: cwd,
+    logLevel,
+    keepNames,
+    write,
+    legalComments: "none"
+  });
+}
+function buildEntrypoint({
+  cwd,
+  minify = true,
+  bundle = true,
+  sourcemap = false,
+  logLevel = "silent",
+  outfile,
+  entrypoint,
+  write
+}) {
+  return (0, import_esbuild.build)({
+    entryPoints: [entrypoint],
+    logOverride: {
+      "equals-negative-zero": "silent"
+    },
+    platform: "node",
+    target: "es2020",
+    sourcemap,
+    minify,
+    bundle,
+    outfile,
+    absWorkingDir: cwd,
+    logLevel,
+    keepNames,
+    write
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCode,
+  buildEntrypoint
+});
+//# sourceMappingURL=esbuild-utils.js.map

package/dist/utils/esbuild-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/esbuild-utils.ts"],
+  "sourcesContent": ["import { build as esbuild, LogLevel, Platform, BuildResult, OutputFile } from 'esbuild'\n\ntype BaseProps<W extends boolean = true> = {\n  cwd: string\n  outfile: string\n  minify?: boolean\n  sourcemap?: boolean\n  bundle?: boolean\n  logLevel?: LogLevel\n  write: W\n  platform?: Platform\n}\n\nexport type BuildCodeProps<W extends boolean = true> = BaseProps<W> & {\n  code: string\n}\n\nexport type BuildEntrypointProps<W extends boolean = true> = BaseProps<W> & {\n  entrypoint: string\n}\n\nconst keepNames = true // important : https://github.com/node-fetch/node-fetch/issues/784#issuecomment-1014768204\n\nexport function buildCode(p: BuildCodeProps<true>): Promise<BuildResult>\nexport function buildCode(p: BuildCodeProps<false>): Promise<BuildResult & { outputFiles: OutputFile[] }>\nexport function buildCode<W extends boolean>({\n  cwd,\n  minify = true,\n  bundle = true,\n  sourcemap = false,\n  logLevel = 'silent',\n  outfile,\n  code,\n  write,\n  platform = 'node',\n}: BuildCodeProps<W>) {\n  return esbuild({\n    stdin: {\n      contents: code,\n      resolveDir: cwd,\n      loader: 'ts',\n    },\n    logOverride: {\n      'equals-negative-zero': 'silent',\n    },\n    platform,\n    target: 'es2020',\n    sourcemap,\n    minify,\n    bundle,\n    outfile,\n    absWorkingDir: cwd,\n    logLevel,\n    keepNames,\n    write,\n    legalComments: 'none',\n  })\n}\n\nexport function buildEntrypoint(p: BuildEntrypointProps<true>): Promise<BuildResult>\nexport function buildEntrypoint(p: BuildEntrypointProps<false>): Promise<BuildResult & { outputFiles: OutputFile[] }>\nexport function buildEntrypoint<W extends boolean>({\n  cwd,\n  minify = true,\n  bundle = true,\n  sourcemap = false,\n  logLevel = 'silent',\n  outfile,\n  entrypoint,\n  write,\n}: BuildEntrypointProps<W>) {\n  return esbuild({\n    entryPoints: [entrypoint],\n    logOverride: {\n      'equals-negative-zero': 'silent',\n    },\n    platform: 'node',\n    target: 'es2020',\n    sourcemap,\n    minify,\n    bundle,\n    outfile,\n    absWorkingDir: cwd,\n    logLevel,\n    keepNames,\n    write,\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA8E;AAqB9E,MAAM,YAAY;AAIX,SAAS,UAA6B;AAAA,EAC3C;AAAA,EACA,SAAS;AAAA,EACT,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AAAA,EACA,WAAW;AACb,GAAsB;AACpB,aAAO,eAAAA,OAAQ;AAAA,IACb,OAAO;AAAA,MACL,UAAU;AAAA,MACV,YAAY;AAAA,MACZ,QAAQ;AAAA,IACV;AAAA,IACA,aAAa;AAAA,MACX,wBAAwB;AAAA,IAC1B;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,eAAe;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA,eAAe;AAAA,EACjB,CAAC;AACH;AAIO,SAAS,gBAAmC;AAAA,EACjD;AAAA,EACA,SAAS;AAAA,EACT,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AACF,GAA4B;AAC1B,aAAO,eAAAA,OAAQ;AAAA,IACb,aAAa,CAAC,UAAU;AAAA,IACxB,aAAa;AAAA,MACX,wBAAwB;AAAA,IAC1B;AAAA,IACA,UAAU;AAAA,IACV,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,eAAe;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;",
+  "names": ["esbuild"]
+}

package/dist/utils/event-emitter.js

@@ -0,0 +1,63 @@
+"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);
+var event_emitter_exports = {};
+__export(event_emitter_exports, {
+  EventEmitter: () => EventEmitter
+});
+module.exports = __toCommonJS(event_emitter_exports);
+class EventEmitter {
+  _listeners = {};
+  emit(type, event) {
+    const listeners = this._listeners[type];
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  once(type, listener) {
+    const wrapped = (event) => {
+      this.off(type, wrapped);
+      listener(event);
+    };
+    this.on(type, wrapped);
+  }
+  on(type, listener) {
+    if (!this._listeners[type]) {
+      this._listeners[type] = [];
+    }
+    this._listeners[type].push(listener);
+  }
+  off(type, listener) {
+    const listeners = this._listeners[type];
+    if (!listeners) {
+      return;
+    }
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventEmitter
+});
+//# sourceMappingURL=event-emitter.js.map

package/dist/utils/event-emitter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/event-emitter.ts"],
+  "sourcesContent": ["export class EventEmitter<E extends object> {\n  private _listeners: {\n    [K in keyof E]?: ((event: E[K]) => void)[]\n  } = {}\n\n  public emit<K extends keyof E>(type: K, event: E[K]) {\n    const listeners = this._listeners[type]\n    if (!listeners) {\n      return\n    }\n    for (const listener of listeners) {\n      listener(event)\n    }\n  }\n\n  public once<K extends keyof E>(type: K, listener: (event: E[K]) => void) {\n    const wrapped = (event: E[K]) => {\n      this.off(type, wrapped)\n      listener(event)\n    }\n    this.on(type, wrapped)\n  }\n\n  public on<K extends keyof E>(type: K, listener: (event: E[K]) => void) {\n    if (!this._listeners[type]) {\n      this._listeners[type] = []\n    }\n    this._listeners[type]!.push(listener)\n  }\n\n  public off<K extends keyof E>(type: K, listener: (event: E[K]) => void) {\n    const listeners = this._listeners[type]\n    if (!listeners) {\n      return\n    }\n    const index = listeners.indexOf(listener)\n    if (index !== -1) {\n      listeners.splice(index, 1)\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,aAA+B;AAAA,EAClC,aAEJ,CAAC;AAAA,EAEE,KAAwB,MAAS,OAAa;AACnD,UAAM,YAAY,KAAK,WAAW,IAAI;AACtC,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AACA,eAAW,YAAY,WAAW;AAChC,eAAS,KAAK;AAAA,IAChB;AAAA,EACF;AAAA,EAEO,KAAwB,MAAS,UAAiC;AACvE,UAAM,UAAU,CAAC,UAAgB;AAC/B,WAAK,IAAI,MAAM,OAAO;AACtB,eAAS,KAAK;AAAA,IAChB;AACA,SAAK,GAAG,MAAM,OAAO;AAAA,EACvB;AAAA,EAEO,GAAsB,MAAS,UAAiC;AACrE,QAAI,CAAC,KAAK,WAAW,IAAI,GAAG;AAC1B,WAAK,WAAW,IAAI,IAAI,CAAC;AAAA,IAC3B;AACA,SAAK,WAAW,IAAI,EAAG,KAAK,QAAQ;AAAA,EACtC;AAAA,EAEO,IAAuB,MAAS,UAAiC;AACtE,UAAM,YAAY,KAAK,WAAW,IAAI;AACtC,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AACA,UAAM,QAAQ,UAAU,QAAQ,QAAQ;AACxC,QAAI,UAAU,IAAI;AAChB,gBAAU,OAAO,OAAO,CAAC;AAAA,IAC3B;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/utils/file-watcher.js

@@ -0,0 +1,73 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_watcher_exports = {};
+__export(file_watcher_exports, {
+  FileWatcher: () => FileWatcher
+});
+module.exports = __toCommonJS(file_watcher_exports);
+var import_watcher = __toESM(require("@parcel/watcher"));
+var import_event_emitter = require("./event-emitter");
+class FileWatcher {
+  constructor(_subscription, _errorEmitter) {
+    this._subscription = _subscription;
+    this._errorEmitter = _errorEmitter;
+  }
+  static async watch(dir, fn, opt) {
+    const eventEmitter = new import_event_emitter.EventEmitter();
+    const subscription = await import_watcher.default.subscribe(
+      dir,
+      async (err, events) => {
+        if (err) {
+          eventEmitter.emit("error", err);
+          return;
+        }
+        try {
+          await fn(events);
+        } catch (thrown) {
+          eventEmitter.emit("error", thrown);
+        }
+      },
+      opt
+    );
+    return new FileWatcher(subscription, eventEmitter);
+  }
+  async close() {
+    await this._subscription.unsubscribe();
+    this._errorEmitter.emit("close", {});
+  }
+  wait = () => new Promise((resolve, reject) => {
+    this._errorEmitter.once("error", reject);
+    this._errorEmitter.once("close", resolve);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileWatcher
+});
+//# sourceMappingURL=file-watcher.js.map

package/dist/utils/file-watcher.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/file-watcher.ts"],
+  "sourcesContent": ["import watcher from '@parcel/watcher'\nimport { EventEmitter } from './event-emitter'\n\nexport type FileChangeHandler = (events: watcher.Event[]) => Promise<void>\n\ntype EmptyObject = Record<never, never>\ntype FileWatcherEvent = {\n  error: unknown\n  close: EmptyObject\n}\n\n/**\n * Wraps the Parcel file watcher to ensure errors can be catched in an async/await fashion\n */\nexport class FileWatcher {\n  public static async watch(dir: string, fn: FileChangeHandler, opt?: watcher.Options) {\n    const eventEmitter = new EventEmitter<FileWatcherEvent>()\n    const subscription = await watcher.subscribe(\n      dir,\n      async (err: Error | null, events: watcher.Event[]) => {\n        if (err) {\n          eventEmitter.emit('error', err)\n          return\n        }\n\n        try {\n          await fn(events)\n        } catch (thrown) {\n          eventEmitter.emit('error', thrown)\n        }\n      },\n      opt\n    )\n    return new FileWatcher(subscription, eventEmitter)\n  }\n\n  private constructor(\n    private _subscription: watcher.AsyncSubscription,\n    private _errorEmitter: EventEmitter<FileWatcherEvent>\n  ) {}\n\n  public async close() {\n    await this._subscription.unsubscribe()\n    this._errorEmitter.emit('close', {})\n  }\n\n  public wait = () =>\n    new Promise((resolve, reject) => {\n      this._errorEmitter.once('error', reject)\n      this._errorEmitter.once('close', resolve)\n    })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAoB;AACpB,2BAA6B;AAatB,MAAM,YAAY;AAAA,EAsBf,YACE,eACA,eACR;AAFQ;AACA;AAAA,EACP;AAAA,EAxBH,aAAoB,MAAM,KAAa,IAAuB,KAAuB;AACnF,UAAM,eAAe,IAAI,kCAA+B;AACxD,UAAM,eAAe,MAAM,eAAAA,QAAQ;AAAA,MACjC;AAAA,MACA,OAAO,KAAmB,WAA4B;AACpD,YAAI,KAAK;AACP,uBAAa,KAAK,SAAS,GAAG;AAC9B;AAAA,QACF;AAEA,YAAI;AACF,gBAAM,GAAG,MAAM;AAAA,QACjB,SAAS,QAAP;AACA,uBAAa,KAAK,SAAS,MAAM;AAAA,QACnC;AAAA,MACF;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI,YAAY,cAAc,YAAY;AAAA,EACnD;AAAA,EAOA,MAAa,QAAQ;AACnB,UAAM,KAAK,cAAc,YAAY;AACrC,SAAK,cAAc,KAAK,SAAS,CAAC,CAAC;AAAA,EACrC;AAAA,EAEO,OAAO,MACZ,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC/B,SAAK,cAAc,KAAK,SAAS,MAAM;AACvC,SAAK,cAAc,KAAK,SAAS,OAAO;AAAA,EAC1C,CAAC;AACL;",
+  "names": ["watcher"]
+}

package/dist/utils/guard-utils.js

@@ -0,0 +1,32 @@
+"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);
+var guard_utils_exports = {};
+__export(guard_utils_exports, {
+  is: () => is
+});
+module.exports = __toCommonJS(guard_utils_exports);
+const is = {
+  defined: (value) => value !== void 0,
+  notNull: (value) => value !== null
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  is
+});
+//# sourceMappingURL=guard-utils.js.map

package/dist/utils/guard-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/guard-utils.ts"],
+  "sourcesContent": ["export const is = {\n  defined: <T>(value: T | undefined): value is T => value !== undefined,\n  notNull: <T>(value: T | null): value is T => value !== null,\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,KAAK;AAAA,EAChB,SAAS,CAAI,UAAqC,UAAU;AAAA,EAC5D,SAAS,CAAI,UAAgC,UAAU;AACzD;",
+  "names": []
+}