@botpress/adk-cli 1.2.1 → 1.4.0

package/dist/bp-cli/dist/utils/file-watcher.js

@@ -0,0 +1,74 @@
+"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_concurrency_utils = require("./concurrency-utils");
+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();
+    let subscriptionHandler = async (err, events) => {
+      if (err) {
+        eventEmitter.emit("error", err);
+        return;
+      }
+      try {
+        await fn(events);
+      } catch (thrown) {
+        eventEmitter.emit("error", thrown);
+      }
+    };
+    if (opt?.debounceMs) {
+      subscriptionHandler = (0, import_concurrency_utils.debounceAsync)(subscriptionHandler, opt.debounceMs);
+    }
+    const subscription = await import_watcher.default.subscribe(dir, subscriptionHandler, 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/bp-cli/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 { debounceAsync } from './concurrency-utils'\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\ntype FileWatcherOptions = watcher.Options & {\n  debounceMs?: number\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?: FileWatcherOptions) {\n    const eventEmitter = new EventEmitter<FileWatcherEvent>()\n\n    let subscriptionHandler = 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\n    if (opt?.debounceMs) {\n      subscriptionHandler = debounceAsync(subscriptionHandler, opt.debounceMs)\n    }\n\n    const subscription = await watcher.subscribe(dir, subscriptionHandler, opt)\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,+BAA8B;AAC9B,2BAA6B;AAiBtB,MAAM,YAAY;AAAA,EAyBf,YACE,eACA,eACR;AAFQ;AACA;AAAA,EACP;AAAA,EA3BH,aAAoB,MAAM,KAAa,IAAuB,KAA0B;AACtF,UAAM,eAAe,IAAI,kCAA+B;AAExD,QAAI,sBAAsB,OAAO,KAAmB,WAA4B;AAC9E,UAAI,KAAK;AACP,qBAAa,KAAK,SAAS,GAAG;AAC9B;AAAA,MACF;AAEA,UAAI;AACF,cAAM,GAAG,MAAM;AAAA,MACjB,SAAS,QAAQ;AACf,qBAAa,KAAK,SAAS,MAAM;AAAA,MACnC;AAAA,IACF;AAEA,QAAI,KAAK,YAAY;AACnB,gCAAsB,wCAAc,qBAAqB,IAAI,UAAU;AAAA,IACzE;AAEA,UAAM,eAAe,MAAM,eAAAA,QAAQ,UAAU,KAAK,qBAAqB,GAAG;AAC1E,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/bp-cli/dist/utils/guard-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const is: {
+    defined: <T>(value: T | undefined) => value is T;
+    notNull: <T>(value: T | null) => value is T;
+};

package/dist/bp-cli/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/bp-cli/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": []
+}

package/dist/bp-cli/dist/utils/id-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidID(id: string): boolean;
+export declare function isPrefixedULID(id: string): boolean;

package/dist/bp-cli/dist/utils/id-utils.js

@@ -0,0 +1,59 @@
+"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 id_utils_exports = {};
+__export(id_utils_exports, {
+  isPrefixedULID: () => isPrefixedULID,
+  isValidID: () => isValidID
+});
+module.exports = __toCommonJS(id_utils_exports);
+var import_const = require("@bpinternal/const");
+var uuid = __toESM(require("uuid"));
+const ULID_LENGTH = 26;
+function isValidID(id) {
+  return isPrefixedULID(id) || uuid.validate(id);
+}
+function isPrefixedULID(id) {
+  const [prefix, identifier] = id.split("_");
+  if (!(prefix && identifier)) {
+    return false;
+  }
+  if (!Object.keys(import_const.prefixToObjectMap).includes(prefix)) {
+    return false;
+  }
+  if (identifier.length < ULID_LENGTH) {
+    return false;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPrefixedULID,
+  isValidID
+});
+//# sourceMappingURL=id-utils.js.map

package/dist/bp-cli/dist/utils/id-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/id-utils.ts"],
+  "sourcesContent": ["import { prefixToObjectMap } from '@bpinternal/const'\nimport * as uuid from 'uuid'\n\nconst ULID_LENGTH = 26 // Reference: https://github.com/ulid/spec#canonical-string-representation\n\nexport function isValidID(id: string) {\n  // Note: UUIDs were used first and then prefixed ULIDs were introduced.\n  return isPrefixedULID(id) || uuid.validate(id)\n}\n\nexport function isPrefixedULID(id: string) {\n  const [prefix, identifier] = id.split('_')\n\n  if (!(prefix && identifier)) {\n    return false\n  }\n\n  if (!Object.keys(prefixToObjectMap).includes(prefix)) {\n    return false\n  }\n\n  if (identifier.length < ULID_LENGTH) {\n    return false\n  }\n\n  return true\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkC;AAClC,WAAsB;AAEtB,MAAM,cAAc;AAEb,SAAS,UAAU,IAAY;AAEpC,SAAO,eAAe,EAAE,KAAK,KAAK,SAAS,EAAE;AAC/C;AAEO,SAAS,eAAe,IAAY;AACzC,QAAM,CAAC,QAAQ,UAAU,IAAI,GAAG,MAAM,GAAG;AAEzC,MAAI,EAAE,UAAU,aAAa;AAC3B,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,OAAO,KAAK,8BAAiB,EAAE,SAAS,MAAM,GAAG;AACpD,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,SAAS,aAAa;AACnC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/index.d.ts

@@ -0,0 +1,22 @@
+export * as attributes from './attribute-utils';
+export * as cache from './cache-utils';
+export * as casing from './case-utils';
+export * as emitter from './event-emitter';
+export * as esbuild from './esbuild-utils';
+export * as filewatcher from './file-watcher';
+export * as guards from './guard-utils';
+export * as id from './id-utils';
+export * as object from './object-utils';
+export * as path from './path-utils';
+export * as pkgJson from './pkgjson-utils';
+export * as promises from './promise-utils';
+export * as prompt from './prompt-utils';
+export * as records from './record-utils';
+export * as require from './require-utils';
+export * as schema from './schema-utils';
+export * as semver from './semver-utils';
+export * as string from './string-utils';
+export * as template from './template-utils';
+export * as tunnel from './tunnel-utils';
+export * as types from './type-utils';
+export * as url from './url-utils';

package/dist/bp-cli/dist/utils/index.js

@@ -0,0 +1,102 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  attributes: () => attributes,
+  cache: () => cache,
+  casing: () => casing,
+  emitter: () => emitter,
+  esbuild: () => esbuild,
+  filewatcher: () => filewatcher,
+  guards: () => guards,
+  id: () => id,
+  object: () => object,
+  path: () => path,
+  pkgJson: () => pkgJson,
+  promises: () => promises,
+  prompt: () => prompt,
+  records: () => records,
+  require: () => require2,
+  schema: () => schema,
+  semver: () => semver,
+  string: () => string,
+  template: () => template,
+  tunnel: () => tunnel,
+  types: () => types,
+  url: () => url
+});
+module.exports = __toCommonJS(utils_exports);
+var attributes = __toESM(require("./attribute-utils"));
+var cache = __toESM(require("./cache-utils"));
+var casing = __toESM(require("./case-utils"));
+var emitter = __toESM(require("./event-emitter"));
+var esbuild = __toESM(require("./esbuild-utils"));
+var filewatcher = __toESM(require("./file-watcher"));
+var guards = __toESM(require("./guard-utils"));
+var id = __toESM(require("./id-utils"));
+var object = __toESM(require("./object-utils"));
+var path = __toESM(require("./path-utils"));
+var pkgJson = __toESM(require("./pkgjson-utils"));
+var promises = __toESM(require("./promise-utils"));
+var prompt = __toESM(require("./prompt-utils"));
+var records = __toESM(require("./record-utils"));
+var require2 = __toESM(require("./require-utils"));
+var schema = __toESM(require("./schema-utils"));
+var semver = __toESM(require("./semver-utils"));
+var string = __toESM(require("./string-utils"));
+var template = __toESM(require("./template-utils"));
+var tunnel = __toESM(require("./tunnel-utils"));
+var types = __toESM(require("./type-utils"));
+var url = __toESM(require("./url-utils"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  attributes,
+  cache,
+  casing,
+  emitter,
+  esbuild,
+  filewatcher,
+  guards,
+  id,
+  object,
+  path,
+  pkgJson,
+  promises,
+  prompt,
+  records,
+  require,
+  schema,
+  semver,
+  string,
+  template,
+  tunnel,
+  types,
+  url
+});
+//# sourceMappingURL=index.js.map

package/dist/bp-cli/dist/utils/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/index.ts"],
+  "sourcesContent": ["export * as attributes from './attribute-utils'\nexport * as cache from './cache-utils'\nexport * as casing from './case-utils'\nexport * as emitter from './event-emitter'\nexport * as esbuild from './esbuild-utils'\nexport * as filewatcher from './file-watcher'\nexport * as guards from './guard-utils'\nexport * as id from './id-utils'\nexport * as object from './object-utils'\nexport * as path from './path-utils'\nexport * as pkgJson from './pkgjson-utils'\nexport * as promises from './promise-utils'\nexport * as prompt from './prompt-utils'\nexport * as records from './record-utils'\nexport * as require from './require-utils'\nexport * as schema from './schema-utils'\nexport * as semver from './semver-utils'\nexport * as string from './string-utils'\nexport * as template from './template-utils'\nexport * as tunnel from './tunnel-utils'\nexport * as types from './type-utils'\nexport * as url from './url-utils'\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA4B;AAC5B,YAAuB;AACvB,aAAwB;AACxB,cAAyB;AACzB,cAAyB;AACzB,kBAA6B;AAC7B,aAAwB;AACxB,SAAoB;AACpB,aAAwB;AACxB,WAAsB;AACtB,cAAyB;AACzB,eAA0B;AAC1B,aAAwB;AACxB,cAAyB;AACzB,IAAAA,WAAyB;AACzB,aAAwB;AACxB,aAAwB;AACxB,aAAwB;AACxB,eAA0B;AAC1B,aAAwB;AACxB,YAAuB;AACvB,UAAqB;",
+  "names": ["require"]
+}

package/dist/bp-cli/dist/utils/object-utils.d.ts

@@ -0,0 +1 @@
+export declare const omit: <O extends object, K extends keyof O>(obj: O, property: K) => Omit<O, K>;

package/dist/bp-cli/dist/utils/object-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 object_utils_exports = {};
+__export(object_utils_exports, {
+  omit: () => omit
+});
+module.exports = __toCommonJS(object_utils_exports);
+const omit = (obj, property) => {
+  const { [property]: _, ...rest } = obj;
+  return rest;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  omit
+});
+//# sourceMappingURL=object-utils.js.map

package/dist/bp-cli/dist/utils/object-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/object-utils.ts"],
+  "sourcesContent": ["export const omit = <O extends object, K extends keyof O>(obj: O, property: K): Omit<O, K> => {\n  const { [property]: _, ...rest } = obj\n  return rest\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,OAAO,CAAsC,KAAQ,aAA4B;AAC5F,QAAM,EAAE,CAAC,QAAQ,GAAG,GAAG,GAAG,KAAK,IAAI;AACnC,SAAO;AACT;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/path-utils.d.ts

@@ -0,0 +1,28 @@
+export declare namespace posix {
+    type AbsolutePath = `/${string}`;
+    const isPath: (path: string) => boolean;
+    const isRelativePath: (path: string) => boolean;
+    const isAbsolutePath: (path: string) => path is AbsolutePath;
+}
+export declare namespace win32 {
+    type AbsolutePath = `${string}:\\${string}`;
+    const isPath: (path: string) => boolean;
+    const isRelativePath: (path: string) => boolean;
+    const isAbsolutePath: (path: string) => path is AbsolutePath;
+}
+export type AbsolutePath = posix.AbsolutePath | win32.AbsolutePath;
+export declare const isPath: (path: string) => boolean;
+export declare const isPlatformSpecificPath: (path: string) => boolean;
+export declare const isPlatformSpecificAbsolutePath: (path: string) => path is AbsolutePath;
+export declare const cwd: () => AbsolutePath;
+export declare const join: (abs: AbsolutePath, ...paths: string[]) => AbsolutePath;
+export declare const rmExtension: (filename: string) => string;
+export declare const toUnix: (path: string) => string;
+export declare const toNormalizedPosixPath: (path: string) => string;
+export declare const absoluteFrom: (rootdir: AbsolutePath, target: string) => AbsolutePath;
+export declare const relativeFrom: (rootdir: AbsolutePath, target: string) => string;
+export declare class PathStore<P extends string> {
+    readonly abs: Record<P, AbsolutePath>;
+    constructor(abs: Record<P, AbsolutePath>);
+    rel(from: Extract<P, `${string}Dir`>): Record<P, AbsolutePath> extends infer T extends object ? { [P_1 in keyof T]: string; } : never;
+}

package/dist/bp-cli/dist/utils/path-utils.js

@@ -0,0 +1,111 @@
+"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 path_utils_exports = {};
+__export(path_utils_exports, {
+  PathStore: () => PathStore,
+  absoluteFrom: () => absoluteFrom,
+  cwd: () => cwd,
+  isPath: () => isPath,
+  isPlatformSpecificAbsolutePath: () => isPlatformSpecificAbsolutePath,
+  isPlatformSpecificPath: () => isPlatformSpecificPath,
+  join: () => join,
+  posix: () => posix,
+  relativeFrom: () => relativeFrom,
+  rmExtension: () => rmExtension,
+  toNormalizedPosixPath: () => toNormalizedPosixPath,
+  toUnix: () => toUnix,
+  win32: () => win32
+});
+module.exports = __toCommonJS(path_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var posix;
+((posix2) => {
+  posix2.isPath = (path) => (0, posix2.isAbsolutePath)(path) || (0, posix2.isRelativePath)(path);
+  posix2.isRelativePath = (path) => path.startsWith("./") || path.startsWith("../");
+  posix2.isAbsolutePath = (path) => import_path.default.posix.isAbsolute(path);
+})(posix || (posix = {}));
+var win32;
+((win322) => {
+  win322.isPath = (path) => (0, win322.isAbsolutePath)(path) || (0, win322.isRelativePath)(path);
+  win322.isRelativePath = (path) => path.startsWith(".\\") || path.startsWith("..\\");
+  win322.isAbsolutePath = (path) => /^[a-zA-Z]:\\/.test(path);
+})(win32 || (win32 = {}));
+const isPath = (path) => win32.isPath(path) || posix.isPath(path);
+const isPlatformSpecificPath = (path) => import_os.default.platform() === "win32" ? win32.isPath(path) : posix.isPath(path);
+const isPlatformSpecificAbsolutePath = (path) => import_os.default.platform() === "win32" ? win32.isAbsolutePath(path) : posix.isAbsolutePath(path);
+const cwd = () => process.cwd();
+const join = (abs, ...paths) => {
+  const joined = import_path.default.join(abs, ...paths);
+  return import_path.default.normalize(joined);
+};
+const rmExtension = (filename) => filename.replace(/\.[^/.]+$/, "");
+const toUnix = (path) => path.split(import_path.default.sep).join(import_path.default.posix.sep);
+const toNormalizedPosixPath = (path) => (path.startsWith("./") ? "./" : "") + import_path.default.posix.normalize(path.replaceAll(/\\/g, "/")).replace(/\/\.$/, "");
+const absoluteFrom = (rootdir, target) => {
+  if (isPlatformSpecificAbsolutePath(target)) {
+    return target;
+  }
+  return import_path.default.join(rootdir, target);
+};
+const relativeFrom = (rootdir, target) => {
+  let absPath;
+  if (isPlatformSpecificAbsolutePath(target)) {
+    absPath = target;
+  } else {
+    absPath = import_path.default.resolve(import_path.default.join(rootdir, target));
+  }
+  return import_path.default.relative(rootdir, absPath);
+};
+class PathStore {
+  constructor(abs) {
+    this.abs = abs;
+  }
+  rel(from) {
+    return import_lodash.default.mapValues(this.abs, (to) => relativeFrom(this.abs[from], to));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PathStore,
+  absoluteFrom,
+  cwd,
+  isPath,
+  isPlatformSpecificAbsolutePath,
+  isPlatformSpecificPath,
+  join,
+  posix,
+  relativeFrom,
+  rmExtension,
+  toNormalizedPosixPath,
+  toUnix,
+  win32
+});
+//# sourceMappingURL=path-utils.js.map

package/dist/bp-cli/dist/utils/path-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/path-utils.ts"],
+  "sourcesContent": ["import _ from 'lodash'\nimport oslib from 'os'\nimport pathlib from 'path'\n\nexport namespace posix {\n  export type AbsolutePath = `/${string}`\n  export const isPath = (path: string) => isAbsolutePath(path) || isRelativePath(path)\n  export const isRelativePath = (path: string) => path.startsWith('./') || path.startsWith('../')\n  export const isAbsolutePath = (path: string): path is AbsolutePath => pathlib.posix.isAbsolute(path)\n}\n\nexport namespace win32 {\n  export type AbsolutePath = `${string}:\\\\${string}` // C:\\path\n  export const isPath = (path: string) => isAbsolutePath(path) || isRelativePath(path)\n  export const isRelativePath = (path: string) => path.startsWith('.\\\\') || path.startsWith('..\\\\')\n  export const isAbsolutePath = (path: string): path is AbsolutePath => /^[a-zA-Z]:\\\\/.test(path) // bp cli does not allow omitting the drive letter\n}\n\nexport type AbsolutePath = posix.AbsolutePath | win32.AbsolutePath\nexport const isPath = (path: string) => win32.isPath(path) || posix.isPath(path)\nexport const isPlatformSpecificPath = (path: string) =>\n  oslib.platform() === 'win32' ? win32.isPath(path) : posix.isPath(path)\nexport const isPlatformSpecificAbsolutePath = (path: string): path is AbsolutePath =>\n  oslib.platform() === 'win32' ? win32.isAbsolutePath(path) : posix.isAbsolutePath(path)\n\nexport const cwd = (): AbsolutePath => process.cwd() as AbsolutePath\nexport const join = (abs: AbsolutePath, ...paths: string[]): AbsolutePath => {\n  const joined = pathlib.join(abs, ...paths)\n  return pathlib.normalize(joined) as AbsolutePath\n}\n\nexport const rmExtension = (filename: string) => filename.replace(/\\.[^/.]+$/, '')\n\nexport const toUnix = (path: string) => path.split(pathlib.sep).join(pathlib.posix.sep)\n\nexport const toNormalizedPosixPath = (path: string) =>\n  (path.startsWith('./') ? './' : '') + pathlib.posix.normalize(path.replaceAll(/\\\\/g, '/')).replace(/\\/\\.$/, '')\n\nexport const absoluteFrom = (rootdir: AbsolutePath, target: string): AbsolutePath => {\n  if (isPlatformSpecificAbsolutePath(target)) {\n    return target\n  }\n  return pathlib.join(rootdir, target) as AbsolutePath\n}\n\nexport const relativeFrom = (rootdir: AbsolutePath, target: string) => {\n  let absPath: string\n\n  if (isPlatformSpecificAbsolutePath(target)) {\n    absPath = target\n  } else {\n    absPath = pathlib.resolve(pathlib.join(rootdir, target))\n  }\n\n  return pathlib.relative(rootdir, absPath)\n}\n\nexport class PathStore<P extends string> {\n  public constructor(public readonly abs: Record<P, AbsolutePath>) {}\n  public rel(from: Extract<P, `${string}Dir`>) {\n    return _.mapValues(this.abs, (to) => relativeFrom(this.abs[from], to))\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AACd,gBAAkB;AAClB,kBAAoB;AAEb,IAAU;AAAA,CAAV,CAAUA,WAAV;AAEE,EAAMA,OAAA,SAAS,CAAC,aAAiBA,OAAA,gBAAe,IAAI,SAAKA,OAAA,gBAAe,IAAI;AAC5E,EAAMA,OAAA,iBAAiB,CAAC,SAAiB,KAAK,WAAW,IAAI,KAAK,KAAK,WAAW,KAAK;AACvF,EAAMA,OAAA,iBAAiB,CAAC,SAAuC,YAAAC,QAAQ,MAAM,WAAW,IAAI;AAAA,GAJpF;AAOV,IAAU;AAAA,CAAV,CAAUC,WAAV;AAEE,EAAMA,OAAA,SAAS,CAAC,aAAiBA,OAAA,gBAAe,IAAI,SAAKA,OAAA,gBAAe,IAAI;AAC5E,EAAMA,OAAA,iBAAiB,CAAC,SAAiB,KAAK,WAAW,KAAK,KAAK,KAAK,WAAW,MAAM;AACzF,EAAMA,OAAA,iBAAiB,CAAC,SAAuC,eAAe,KAAK,IAAI;AAAA,GAJ/E;AAQV,MAAM,SAAS,CAAC,SAAiB,MAAM,OAAO,IAAI,KAAK,MAAM,OAAO,IAAI;AACxE,MAAM,yBAAyB,CAAC,SACrC,UAAAC,QAAM,SAAS,MAAM,UAAU,MAAM,OAAO,IAAI,IAAI,MAAM,OAAO,IAAI;AAChE,MAAM,iCAAiC,CAAC,SAC7C,UAAAA,QAAM,SAAS,MAAM,UAAU,MAAM,eAAe,IAAI,IAAI,MAAM,eAAe,IAAI;AAEhF,MAAM,MAAM,MAAoB,QAAQ,IAAI;AAC5C,MAAM,OAAO,CAAC,QAAsB,UAAkC;AAC3E,QAAM,SAAS,YAAAF,QAAQ,KAAK,KAAK,GAAG,KAAK;AACzC,SAAO,YAAAA,QAAQ,UAAU,MAAM;AACjC;AAEO,MAAM,cAAc,CAAC,aAAqB,SAAS,QAAQ,aAAa,EAAE;AAE1E,MAAM,SAAS,CAAC,SAAiB,KAAK,MAAM,YAAAA,QAAQ,GAAG,EAAE,KAAK,YAAAA,QAAQ,MAAM,GAAG;AAE/E,MAAM,wBAAwB,CAAC,UACnC,KAAK,WAAW,IAAI,IAAI,OAAO,MAAM,YAAAA,QAAQ,MAAM,UAAU,KAAK,WAAW,OAAO,GAAG,CAAC,EAAE,QAAQ,SAAS,EAAE;AAEzG,MAAM,eAAe,CAAC,SAAuB,WAAiC;AACnF,MAAI,+BAA+B,MAAM,GAAG;AAC1C,WAAO;AAAA,EACT;AACA,SAAO,YAAAA,QAAQ,KAAK,SAAS,MAAM;AACrC;AAEO,MAAM,eAAe,CAAC,SAAuB,WAAmB;AACrE,MAAI;AAEJ,MAAI,+BAA+B,MAAM,GAAG;AAC1C,cAAU;AAAA,EACZ,OAAO;AACL,cAAU,YAAAA,QAAQ,QAAQ,YAAAA,QAAQ,KAAK,SAAS,MAAM,CAAC;AAAA,EACzD;AAEA,SAAO,YAAAA,QAAQ,SAAS,SAAS,OAAO;AAC1C;AAEO,MAAM,UAA4B;AAAA,EAChC,YAA4B,KAA8B;AAA9B;AAAA,EAA+B;AAAA,EAC3D,IAAI,MAAkC;AAC3C,WAAO,cAAAG,QAAE,UAAU,KAAK,KAAK,CAAC,OAAO,aAAa,KAAK,IAAI,IAAI,GAAG,EAAE,CAAC;AAAA,EACvE;AACF;",
+  "names": ["posix", "pathlib", "win32", "oslib", "_"]
+}

package/dist/bp-cli/dist/utils/path-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bp-cli/dist/utils/path-utils.test.js

@@ -0,0 +1,72 @@
+"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 pathUtils = __toESM(require("./path-utils"));
+(0, import_vitest.describe)("posix", () => {
+  (0, import_vitest.test)("isPath with valid relative path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("../src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./src/services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./src/services/index.ts")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./.././.././../lol.json")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with valid absolute path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src/services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src/services/index.ts")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with invalid path should return false", () => {
+    (0, import_vitest.expect)(pathUtils.posix.isPath("src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath(".src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("..src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("src/services")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("src/services/index.ts")).toBe(false);
+  });
+});
+(0, import_vitest.describe)("win32", () => {
+  (0, import_vitest.test)("isPath with valid relative path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("..\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\src\\services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\src\\services\\index.ts")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\..\\.\\..\\.\\..\\lol.json")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with valid absolute path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src\\services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src\\services\\index.ts")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with invalid path should return false", () => {
+    (0, import_vitest.expect)(pathUtils.win32.isPath("src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("..src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("src\\services")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("src\\services\\index.ts")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("\\services")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("\\services\\index.ts")).toBe(false);
+  });
+});
+//# sourceMappingURL=path-utils.test.js.map

package/dist/bp-cli/dist/utils/path-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/path-utils.test.ts"],
+  "sourcesContent": ["import { test, expect, describe } from 'vitest'\nimport * as pathUtils from './path-utils'\n\ndescribe('posix', () => {\n  test('isPath with valid relative path should return true', () => {\n    expect(pathUtils.posix.isPath('./src')).toBe(true)\n    expect(pathUtils.posix.isPath('../src')).toBe(true)\n    expect(pathUtils.posix.isPath('./src/services')).toBe(true)\n    expect(pathUtils.posix.isPath('./src/services/index.ts')).toBe(true)\n    expect(pathUtils.posix.isPath('./.././.././../lol.json')).toBe(true)\n  })\n\n  test('isPath with valid absolute path should return true', () => {\n    expect(pathUtils.posix.isPath('/src')).toBe(true)\n    expect(pathUtils.posix.isPath('/src')).toBe(true)\n    expect(pathUtils.posix.isPath('/src/services')).toBe(true)\n    expect(pathUtils.posix.isPath('/src/services/index.ts')).toBe(true)\n  })\n\n  test('isPath with invalid path should return false', () => {\n    // these are technically valid posix paths, but not for the bp cli\n    expect(pathUtils.posix.isPath('src')).toBe(false)\n    expect(pathUtils.posix.isPath('.src')).toBe(false)\n    expect(pathUtils.posix.isPath('..src')).toBe(false)\n    expect(pathUtils.posix.isPath('src/services')).toBe(false)\n    expect(pathUtils.posix.isPath('src/services/index.ts')).toBe(false)\n  })\n})\n\ndescribe('win32', () => {\n  test('isPath with valid relative path should return true', () => {\n    expect(pathUtils.win32.isPath('.\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('..\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('.\\\\src\\\\services')).toBe(true)\n    expect(pathUtils.win32.isPath('.\\\\src\\\\services\\\\index.ts')).toBe(true)\n    expect(pathUtils.win32.isPath('.\\\\..\\\\.\\\\..\\\\.\\\\..\\\\lol.json')).toBe(true)\n  })\n\n  test('isPath with valid absolute path should return true', () => {\n    expect(pathUtils.win32.isPath('C:\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('C:\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('C:\\\\src\\\\services')).toBe(true)\n    expect(pathUtils.win32.isPath('C:\\\\src\\\\services\\\\index.ts')).toBe(true)\n  })\n\n  test('isPath with invalid path should return false', () => {\n    // these are technically valid win32 paths, but not for the bp cli\n    expect(pathUtils.win32.isPath('src')).toBe(false)\n    expect(pathUtils.win32.isPath('.src')).toBe(false)\n    expect(pathUtils.win32.isPath('..src')).toBe(false)\n    expect(pathUtils.win32.isPath('src\\\\services')).toBe(false)\n    expect(pathUtils.win32.isPath('src\\\\services\\\\index.ts')).toBe(false)\n    expect(pathUtils.win32.isPath('\\\\services')).toBe(false)\n    expect(pathUtils.win32.isPath('\\\\services\\\\index.ts')).toBe(false)\n  })\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,oBAAuC;AACvC,gBAA2B;AAAA,IAE3B,wBAAS,SAAS,MAAM;AACtB,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,OAAO,CAAC,EAAE,KAAK,IAAI;AACjD,8BAAO,UAAU,MAAM,OAAO,QAAQ,CAAC,EAAE,KAAK,IAAI;AAClD,8BAAO,UAAU,MAAM,OAAO,gBAAgB,CAAC,EAAE,KAAK,IAAI;AAC1D,8BAAO,UAAU,MAAM,OAAO,yBAAyB,CAAC,EAAE,KAAK,IAAI;AACnE,8BAAO,UAAU,MAAM,OAAO,yBAAyB,CAAC,EAAE,KAAK,IAAI;AAAA,EACrE,CAAC;AAED,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,IAAI;AAChD,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,IAAI;AAChD,8BAAO,UAAU,MAAM,OAAO,eAAe,CAAC,EAAE,KAAK,IAAI;AACzD,8BAAO,UAAU,MAAM,OAAO,wBAAwB,CAAC,EAAE,KAAK,IAAI;AAAA,EACpE,CAAC;AAED,0BAAK,gDAAgD,MAAM;AAEzD,8BAAO,UAAU,MAAM,OAAO,KAAK,CAAC,EAAE,KAAK,KAAK;AAChD,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,KAAK;AACjD,8BAAO,UAAU,MAAM,OAAO,OAAO,CAAC,EAAE,KAAK,KAAK;AAClD,8BAAO,UAAU,MAAM,OAAO,cAAc,CAAC,EAAE,KAAK,KAAK;AACzD,8BAAO,UAAU,MAAM,OAAO,uBAAuB,CAAC,EAAE,KAAK,KAAK;AAAA,EACpE,CAAC;AACH,CAAC;AAAA,IAED,wBAAS,SAAS,MAAM;AACtB,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,QAAQ,CAAC,EAAE,KAAK,IAAI;AAClD,8BAAO,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI;AACnD,8BAAO,UAAU,MAAM,OAAO,kBAAkB,CAAC,EAAE,KAAK,IAAI;AAC5D,8BAAO,UAAU,MAAM,OAAO,4BAA4B,CAAC,EAAE,KAAK,IAAI;AACtE,8BAAO,UAAU,MAAM,OAAO,+BAA+B,CAAC,EAAE,KAAK,IAAI;AAAA,EAC3E,CAAC;AAED,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI;AACnD,8BAAO,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI;AACnD,8BAAO,UAAU,MAAM,OAAO,mBAAmB,CAAC,EAAE,KAAK,IAAI;AAC7D,8BAAO,UAAU,MAAM,OAAO,6BAA6B,CAAC,EAAE,KAAK,IAAI;AAAA,EACzE,CAAC;AAED,0BAAK,gDAAgD,MAAM;AAEzD,8BAAO,UAAU,MAAM,OAAO,KAAK,CAAC,EAAE,KAAK,KAAK;AAChD,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,KAAK;AACjD,8BAAO,UAAU,MAAM,OAAO,OAAO,CAAC,EAAE,KAAK,KAAK;AAClD,8BAAO,UAAU,MAAM,OAAO,eAAe,CAAC,EAAE,KAAK,KAAK;AAC1D,8BAAO,UAAU,MAAM,OAAO,yBAAyB,CAAC,EAAE,KAAK,KAAK;AACpE,8BAAO,UAAU,MAAM,OAAO,YAAY,CAAC,EAAE,KAAK,KAAK;AACvD,8BAAO,UAAU,MAAM,OAAO,sBAAsB,CAAC,EAAE,KAAK,KAAK;AAAA,EACnE,CAAC;AACH,CAAC;",
+  "names": []
+}