@mnaoumov/typescript-lib 0.0.0 → 1.0.1

package/dist/lib/esm/transformers/transformer.mjs

@@ -0,0 +1,88 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { getAllKeys } from "../object-utils.mjs";
+class Transformer {
+  /**
+   * Gets the transformer with the given id.
+   *
+   * @param transformerId - The id of the transformer to get.
+   * @returns The transformer with the given id.
+   */
+  // eslint-disable-next-line @typescript-eslint/prefer-return-this-type -- The overridden method might return a different type.
+  getTransformer(transformerId) {
+    if (transformerId === this.id) {
+      return this;
+    }
+    throw new Error(`Transformer with id ${transformerId} not found`);
+  }
+  /**
+   * Transforms the given object recursively.
+   *
+   * @param value - The value to transform.
+   * @returns The transformed value.
+   */
+  transformObjectRecursively(value) {
+    return this.transformValueRecursively(value, "");
+  }
+  /**
+   * Gets the id of the transformer that can transform the given value.
+   *
+   * @param value - The value to get the transformer id for.
+   * @param key - The key of the value to get the transformer id for.
+   * @returns The id of the transformer that can transform the given value.
+   */
+  getTransformerId(value, key) {
+    return this.canTransform(value, key) ? this.id : null;
+  }
+  /**
+   * Transforms the given value recursively.
+   *
+   * @param value - The value to transform.
+   * @param key - The key of the value to transform.
+   * @returns The transformed value.
+   */
+  transformValueRecursively(value, key) {
+    const transformerId = this.getTransformerId(value, key);
+    if (transformerId) {
+      const transformedValue = this.transformValue(value, key);
+      if (transformedValue === void 0) {
+        return void 0;
+      }
+      const wrapper = {
+        __transformerId: transformerId,
+        transformedValue
+      };
+      return wrapper;
+    }
+    if (value === null) {
+      return null;
+    }
+    if (typeof value !== "object") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((childValue, index) => this.transformValueRecursively(childValue, String(index)));
+    }
+    const transformedValueWrapper = value;
+    if (transformedValueWrapper.__transformerId) {
+      return this.getTransformer(transformedValueWrapper.__transformerId).restoreValue(transformedValueWrapper.transformedValue, key);
+    }
+    const record = {};
+    for (const childKey of getAllKeys(value)) {
+      const childValue = value[childKey];
+      const transformedChildValue = this.transformValueRecursively(childValue, childKey);
+      if (transformedChildValue === void 0) {
+        continue;
+      }
+      record[childKey] = transformedChildValue;
+    }
+    return record;
+  }
+}
+export {
+  Transformer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/transformers/transformer.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A base class for transformers.\n */\n\nimport type { GenericObject } from '../type-guards.ts';\n\nimport { getAllKeys } from '../object-utils.ts';\n\n/**\n * A wrapper for a transformed value.\n */\ninterface TransformedValueWrapper {\n  /**\n   * An id of the transformer that transformed the value.\n   */\n  __transformerId: string;\n\n  /**\n   * A transformed value.\n   */\n  transformedValue: unknown;\n}\n\n/**\n * A base class for transformers.\n */\nexport abstract class Transformer {\n  /**\n   * An id of the transformer.\n   */\n  public abstract get id(): string;\n\n  /**\n   * Determines if the transformer can transform the given value.\n   *\n   * @param value - The value to check.\n   * @param key - The key of the value to check.\n   * @returns A boolean indicating if the transformer can transform the value.\n   */\n  public abstract canTransform(value: unknown, key: string): boolean;\n\n  /**\n   * Gets the transformer with the given id.\n   *\n   * @param transformerId - The id of the transformer to get.\n   * @returns The transformer with the given id.\n   */\n  // eslint-disable-next-line @typescript-eslint/prefer-return-this-type -- The overridden method might return a different type.\n  public getTransformer(transformerId: string): Transformer {\n    if (transformerId === this.id) {\n      return this;\n    }\n\n    throw new Error(`Transformer with id ${transformerId} not found`);\n  }\n\n  /**\n   * Transforms the given object recursively.\n   *\n   * @param value - The value to transform.\n   * @returns The transformed value.\n   */\n  public transformObjectRecursively(value: object): GenericObject {\n    return this.transformValueRecursively(value, '') as GenericObject;\n  }\n\n  /**\n   * Transforms the given value.\n   *\n   * @param value - The value to transform.\n   * @param key - The key of the value to transform.\n   * @returns The transformed value.\n   */\n  public abstract transformValue(value: unknown, key: string): unknown;\n\n  /**\n   * Gets the id of the transformer that can transform the given value.\n   *\n   * @param value - The value to get the transformer id for.\n   * @param key - The key of the value to get the transformer id for.\n   * @returns The id of the transformer that can transform the given value.\n   */\n  protected getTransformerId(value: unknown, key: string): null | string {\n    return this.canTransform(value, key) ? this.id : null;\n  }\n\n  /**\n   * Restores the given value.\n   *\n   * @param transformedValue - The value to restore.\n   * @param key - The key of the value to restore.\n   * @returns The restored value.\n   */\n  protected abstract restoreValue(transformedValue: unknown, key: string): unknown;\n\n  /**\n   * Transforms the given value recursively.\n   *\n   * @param value - The value to transform.\n   * @param key - The key of the value to transform.\n   * @returns The transformed value.\n   */\n  private transformValueRecursively(value: unknown, key: string): unknown {\n    const transformerId = this.getTransformerId(value, key);\n    if (transformerId) {\n      const transformedValue = this.transformValue(value, key);\n      if (transformedValue === undefined) {\n        return undefined;\n      }\n\n      const wrapper: TransformedValueWrapper = {\n        __transformerId: transformerId,\n        transformedValue\n      };\n\n      return wrapper;\n    }\n\n    if (value === null) {\n      return null;\n    }\n\n    if (typeof value !== 'object') {\n      return value;\n    }\n\n    if (Array.isArray(value)) {\n      return value.map((childValue, index) => this.transformValueRecursively(childValue, String(index)));\n    }\n\n    const transformedValueWrapper = value as Partial<TransformedValueWrapper>;\n    if (transformedValueWrapper.__transformerId) {\n      return this.getTransformer(transformedValueWrapper.__transformerId).restoreValue(transformedValueWrapper.transformedValue, key);\n    }\n\n    const record: GenericObject = {};\n\n    for (const childKey of getAllKeys(value)) {\n      const childValue = value[childKey];\n      const transformedChildValue = this.transformValueRecursively(childValue, childKey);\n      // JSON cannot hold `undefined`, so a key kept with that value vanishes on the first save and makes the\n      // saved record differ from the one it was built from -- which is what made every settings load rewrite\n      // `data.json`. `SkipPrivatePropertyTransformer` returns `undefined` for every `_`-prefixed key.\n      if (transformedChildValue === undefined) {\n        continue;\n      }\n\n      record[childKey] = transformedChildValue;\n    }\n\n    return record;\n  }\n}\n"],
  "mappings": ";;;;;AAQA,SAAS,kBAAkB;AAoBpB,MAAe,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBzB,eAAe,eAAoC;AACxD,QAAI,kBAAkB,KAAK,IAAI;AAC7B,aAAO;AAAA,IACT;AAEA,UAAM,IAAI,MAAM,uBAAuB,aAAa,YAAY;AAAA,EAClE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,2BAA2B,OAA8B;AAC9D,WAAO,KAAK,0BAA0B,OAAO,EAAE;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBU,iBAAiB,OAAgB,KAA4B;AACrE,WAAO,KAAK,aAAa,OAAO,GAAG,IAAI,KAAK,KAAK;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBQ,0BAA0B,OAAgB,KAAsB;AACtE,UAAM,gBAAgB,KAAK,iBAAiB,OAAO,GAAG;AACtD,QAAI,eAAe;AACjB,YAAM,mBAAmB,KAAK,eAAe,OAAO,GAAG;AACvD,UAAI,qBAAqB,QAAW;AAClC,eAAO;AAAA,MACT;AAEA,YAAM,UAAmC;AAAA,QACvC,iBAAiB;AAAA,QACjB;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAEA,QAAI,UAAU,MAAM;AAClB,aAAO;AAAA,IACT;AAEA,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO;AAAA,IACT;AAEA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO,MAAM,IAAI,CAAC,YAAY,UAAU,KAAK,0BAA0B,YAAY,OAAO,KAAK,CAAC,CAAC;AAAA,IACnG;AAEA,UAAM,0BAA0B;AAChC,QAAI,wBAAwB,iBAAiB;AAC3C,aAAO,KAAK,eAAe,wBAAwB,eAAe,EAAE,aAAa,wBAAwB,kBAAkB,GAAG;AAAA,IAChI;AAEA,UAAM,SAAwB,CAAC;AAE/B,eAAW,YAAY,WAAW,KAAK,GAAG;AACxC,YAAM,aAAa,MAAM,QAAQ;AACjC,YAAM,wBAAwB,KAAK,0BAA0B,YAAY,QAAQ;AAIjF,UAAI,0BAA0B,QAAW;AACvC;AAAA,MACF;AAEA,aAAO,QAAQ,IAAI;AAAA,IACrB;AAEA,WAAO;AAAA,EACT;AACF;",
  "names": []
}


package/dist/lib/esm/transformers/two-way-map-transformer.d.mts

@@ -0,0 +1,42 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * A transformer that can transform a TwoWayMap to an array of entries and back.
+ */
+import { TwoWayMap } from '../two-way-map.mjs';
+import { TypedTransformer } from './typed-transformer.mjs';
+type MapEntry = readonly [key: unknown, value: unknown];
+/**
+ * A transformer that can transform a TwoWayMap to an array of entries and back.
+ */
+export declare class TwoWayMapTransformer extends TypedTransformer<TwoWayMap<unknown, unknown>, MapEntry[]> {
+    /**
+     * Gets the ID of the transformer.
+     *
+     * @returns The ID of the transformer.
+     */
+    get id(): string;
+    /**
+     * Checks if the value is a TwoWayMap.
+     *
+     * @param value - The value to check.
+     * @returns `true` if the value is a TwoWayMap, `false` otherwise.
+     */
+    canTransform(value: unknown): value is TwoWayMap<unknown, unknown>;
+    /**
+     * Restores a TwoWayMap from an array of entries.
+     *
+     * @param transformedValue - The array of entries.
+     * @returns The TwoWayMap.
+     */
+    restoreValue(transformedValue: MapEntry[]): TwoWayMap<unknown, unknown>;
+    /**
+     * Transforms a TwoWayMap to an array of entries.
+     *
+     * @param value - The TwoWayMap.
+     * @returns The array of entries.
+     */
+    transformValue(value: TwoWayMap<unknown, unknown>): MapEntry[];
+}
+export {};

package/dist/lib/esm/transformers/two-way-map-transformer.mjs

@@ -0,0 +1,48 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { TwoWayMap } from "../two-way-map.mjs";
+import { TypedTransformer } from "./typed-transformer.mjs";
+class TwoWayMapTransformer extends TypedTransformer {
+  /**
+   * Gets the ID of the transformer.
+   *
+   * @returns The ID of the transformer.
+   */
+  get id() {
+    return "two-way-map";
+  }
+  /**
+   * Checks if the value is a TwoWayMap.
+   *
+   * @param value - The value to check.
+   * @returns `true` if the value is a TwoWayMap, `false` otherwise.
+   */
+  canTransform(value) {
+    return value instanceof TwoWayMap;
+  }
+  /**
+   * Restores a TwoWayMap from an array of entries.
+   *
+   * @param transformedValue - The array of entries.
+   * @returns The TwoWayMap.
+   */
+  restoreValue(transformedValue) {
+    return new TwoWayMap(transformedValue);
+  }
+  /**
+   * Transforms a TwoWayMap to an array of entries.
+   *
+   * @param value - The TwoWayMap.
+   * @returns The array of entries.
+   */
+  transformValue(value) {
+    return [...value.entries()];
+  }
+}
+export {
+  TwoWayMapTransformer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3RyYW5zZm9ybWVycy90d28td2F5LW1hcC10cmFuc2Zvcm1lci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEEgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIGEgVHdvV2F5TWFwIHRvIGFuIGFycmF5IG9mIGVudHJpZXMgYW5kIGJhY2suXG4gKi9cblxuaW1wb3J0IHsgVHdvV2F5TWFwIH0gZnJvbSAnLi4vdHdvLXdheS1tYXAudHMnO1xuaW1wb3J0IHsgVHlwZWRUcmFuc2Zvcm1lciB9IGZyb20gJy4vdHlwZWQtdHJhbnNmb3JtZXIudHMnO1xuXG50eXBlIE1hcEVudHJ5ID0gcmVhZG9ubHkgW2tleTogdW5rbm93biwgdmFsdWU6IHVua25vd25dO1xuXG4vKipcbiAqIEEgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIGEgVHdvV2F5TWFwIHRvIGFuIGFycmF5IG9mIGVudHJpZXMgYW5kIGJhY2suXG4gKi9cbmV4cG9ydCBjbGFzcyBUd29XYXlNYXBUcmFuc2Zvcm1lciBleHRlbmRzIFR5cGVkVHJhbnNmb3JtZXI8VHdvV2F5TWFwPHVua25vd24sIHVua25vd24+LCBNYXBFbnRyeVtdPiB7XG4gIC8qKlxuICAgKiBHZXRzIHRoZSBJRCBvZiB0aGUgdHJhbnNmb3JtZXIuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBJRCBvZiB0aGUgdHJhbnNmb3JtZXIuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgZ2V0IGlkKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuICd0d28td2F5LW1hcCc7XG4gIH1cblxuICAvKipcbiAgICogQ2hlY2tzIGlmIHRoZSB2YWx1ZSBpcyBhIFR3b1dheU1hcC5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrLlxuICAgKiBAcmV0dXJucyBgdHJ1ZWAgaWYgdGhlIHZhbHVlIGlzIGEgVHdvV2F5TWFwLCBgZmFsc2VgIG90aGVyd2lzZS5cbiAgICovXG4gIHB1YmxpYyBvdmVycmlkZSBjYW5UcmFuc2Zvcm0odmFsdWU6IHVua25vd24pOiB2YWx1ZSBpcyBUd29XYXlNYXA8dW5rbm93biwgdW5rbm93bj4ge1xuICAgIHJldHVybiB2YWx1ZSBpbnN0YW5jZW9mIFR3b1dheU1hcDtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXN0b3JlcyBhIFR3b1dheU1hcCBmcm9tIGFuIGFycmF5IG9mIGVudHJpZXMuXG4gICAqXG4gICAqIEBwYXJhbSB0cmFuc2Zvcm1lZFZhbHVlIC0gVGhlIGFycmF5IG9mIGVudHJpZXMuXG4gICAqIEByZXR1cm5zIFRoZSBUd29XYXlNYXAuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgcmVzdG9yZVZhbHVlKHRyYW5zZm9ybWVkVmFsdWU6IE1hcEVudHJ5W10pOiBUd29XYXlNYXA8dW5rbm93biwgdW5rbm93bj4ge1xuICAgIHJldHVybiBuZXcgVHdvV2F5TWFwPHVua25vd24sIHVua25vd24+KHRyYW5zZm9ybWVkVmFsdWUpO1xuICB9XG5cbiAgLyoqXG4gICAqIFRyYW5zZm9ybXMgYSBUd29XYXlNYXAgdG8gYW4gYXJyYXkgb2YgZW50cmllcy5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIC0gVGhlIFR3b1dheU1hcC5cbiAgICogQHJldHVybnMgVGhlIGFycmF5IG9mIGVudHJpZXMuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgdHJhbnNmb3JtVmFsdWUodmFsdWU6IFR3b1dheU1hcDx1bmtub3duLCB1bmtub3duPik6IE1hcEVudHJ5W10ge1xuICAgIHJldHVybiBbLi4udmFsdWUuZW50cmllcygpXTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFNQSxTQUFTLGlCQUFpQjtBQUMxQixTQUFTLHdCQUF3QjtBQU8xQixNQUFNLDZCQUE2QixpQkFBMEQ7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNbEcsSUFBb0IsS0FBYTtBQUMvQixXQUFPO0FBQUEsRUFDVDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBUWdCLGFBQWEsT0FBc0Q7QUFDakYsV0FBTyxpQkFBaUI7QUFBQSxFQUMxQjtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBUWdCLGFBQWEsa0JBQTJEO0FBQ3RGLFdBQU8sSUFBSSxVQUE0QixnQkFBZ0I7QUFBQSxFQUN6RDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBUWdCLGVBQWUsT0FBZ0Q7QUFDN0UsV0FBTyxDQUFDLEdBQUcsTUFBTSxRQUFRLENBQUM7QUFBQSxFQUM1QjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/transformers/typed-transformer.d.mts

@@ -0,0 +1,39 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * A base class for transformers that can transform and restore a specific type.
+ */
+import { Transformer } from './transformer.mjs';
+/**
+ * A transformer that can transform and restore a specific type.
+ *
+ * @typeParam Source - The type of the source value.
+ * @typeParam Transformed - The type of the transformed value.
+ */
+export declare abstract class TypedTransformer<Source, Transformed> extends Transformer {
+    /**
+     * Determines if the transformer can transform the given value.
+     *
+     * @param value - The value to check.
+     * @param key - The key of the value to check.
+     * @returns A boolean indicating if the transformer can transform the value.
+     */
+    abstract canTransform(value: unknown, key: string): value is Source;
+    /**
+     * Restores the given value.
+     *
+     * @param transformedValue - The value to restore.
+     * @param key - The key of the value to restore.
+     * @returns The restored value.
+     */
+    abstract restoreValue(transformedValue: Transformed, key: string): Source;
+    /**
+     * Transforms the given value.
+     *
+     * @param value - The value to transform.
+     * @param key - The key of the value to transform.
+     * @returns The transformed value.
+     */
+    abstract transformValue(value: Source, key: string): Transformed;
+}

package/dist/lib/esm/transformers/typed-transformer.mjs

@@ -0,0 +1,12 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { Transformer } from "./transformer.mjs";
+class TypedTransformer extends Transformer {
+}
+export {
+  TypedTransformer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3RyYW5zZm9ybWVycy90eXBlZC10cmFuc2Zvcm1lci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEEgYmFzZSBjbGFzcyBmb3IgdHJhbnNmb3JtZXJzIHRoYXQgY2FuIHRyYW5zZm9ybSBhbmQgcmVzdG9yZSBhIHNwZWNpZmljIHR5cGUuXG4gKi9cblxuaW1wb3J0IHsgVHJhbnNmb3JtZXIgfSBmcm9tICcuL3RyYW5zZm9ybWVyLnRzJztcblxuLyoqXG4gKiBBIHRyYW5zZm9ybWVyIHRoYXQgY2FuIHRyYW5zZm9ybSBhbmQgcmVzdG9yZSBhIHNwZWNpZmljIHR5cGUuXG4gKlxuICogQHR5cGVQYXJhbSBTb3VyY2UgLSBUaGUgdHlwZSBvZiB0aGUgc291cmNlIHZhbHVlLlxuICogQHR5cGVQYXJhbSBUcmFuc2Zvcm1lZCAtIFRoZSB0eXBlIG9mIHRoZSB0cmFuc2Zvcm1lZCB2YWx1ZS5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFR5cGVkVHJhbnNmb3JtZXI8U291cmNlLCBUcmFuc2Zvcm1lZD4gZXh0ZW5kcyBUcmFuc2Zvcm1lciB7XG4gIC8qKlxuICAgKiBEZXRlcm1pbmVzIGlmIHRoZSB0cmFuc2Zvcm1lciBjYW4gdHJhbnNmb3JtIHRoZSBnaXZlbiB2YWx1ZS5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrLlxuICAgKiBAcGFyYW0ga2V5IC0gVGhlIGtleSBvZiB0aGUgdmFsdWUgdG8gY2hlY2suXG4gICAqIEByZXR1cm5zIEEgYm9vbGVhbiBpbmRpY2F0aW5nIGlmIHRoZSB0cmFuc2Zvcm1lciBjYW4gdHJhbnNmb3JtIHRoZSB2YWx1ZS5cbiAgICovXG4gIHB1YmxpYyBhYnN0cmFjdCBvdmVycmlkZSBjYW5UcmFuc2Zvcm0odmFsdWU6IHVua25vd24sIGtleTogc3RyaW5nKTogdmFsdWUgaXMgU291cmNlO1xuXG4gIC8qKlxuICAgKiBSZXN0b3JlcyB0aGUgZ2l2ZW4gdmFsdWUuXG4gICAqXG4gICAqIEBwYXJhbSB0cmFuc2Zvcm1lZFZhbHVlIC0gVGhlIHZhbHVlIHRvIHJlc3RvcmUuXG4gICAqIEBwYXJhbSBrZXkgLSBUaGUga2V5IG9mIHRoZSB2YWx1ZSB0byByZXN0b3JlLlxuICAgKiBAcmV0dXJucyBUaGUgcmVzdG9yZWQgdmFsdWUuXG4gICAqL1xuICBwdWJsaWMgYWJzdHJhY3Qgb3ZlcnJpZGUgcmVzdG9yZVZhbHVlKHRyYW5zZm9ybWVkVmFsdWU6IFRyYW5zZm9ybWVkLCBrZXk6IHN0cmluZyk6IFNvdXJjZTtcblxuICAvKipcbiAgICogVHJhbnNmb3JtcyB0aGUgZ2l2ZW4gdmFsdWUuXG4gICAqXG4gICAqIEBwYXJhbSB2YWx1ZSAtIFRoZSB2YWx1ZSB0byB0cmFuc2Zvcm0uXG4gICAqIEBwYXJhbSBrZXkgLSBUaGUga2V5IG9mIHRoZSB2YWx1ZSB0byB0cmFuc2Zvcm0uXG4gICAqIEByZXR1cm5zIFRoZSB0cmFuc2Zvcm1lZCB2YWx1ZS5cbiAgICovXG4gIHB1YmxpYyBhYnN0cmFjdCBvdmVycmlkZSB0cmFuc2Zvcm1WYWx1ZSh2YWx1ZTogU291cmNlLCBrZXk6IHN0cmluZyk6IFRyYW5zZm9ybWVkO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFNQSxTQUFTLG1CQUFtQjtBQVFyQixNQUFlLHlCQUE4QyxZQUFZO0FBMkJoRjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/two-way-map.d.mts

@@ -0,0 +1,101 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Two-way map.
+ */
+/**
+ * A map that allows you to look up a value by its key and vice versa.
+ *
+ * @typeParam Key - The type of the keys.
+ * @typeParam Value - The type of the values.
+ * @example
+ * ```ts
+ * const map = new TwoWayMap<string, number>();
+ * map.set('foo', 42);
+ * map.getValue('foo'); // 42
+ * map.getKey(42); // 'foo'
+ * map.deleteKey('foo');
+ * map.deleteValue(42);
+ * map.clear();
+ * ```
+ */
+export declare class TwoWayMap<Key, Value> {
+    private readonly keyValueMap;
+    private readonly valueKeyMap;
+    /**
+     * Creates a new two-way map.
+     *
+     * @param entries - Entries to initialize the map with.
+     */
+    constructor(entries?: (readonly [key: Key, value: Value])[]);
+    /**
+     * Clears the map.
+     */
+    clear(): void;
+    /**
+     * Deletes a key from the map.
+     *
+     * @param key - The key.
+     */
+    deleteKey(key: Key): void;
+    /**
+     * Deletes a value from the map.
+     *
+     * @param value - The value.
+     */
+    deleteValue(value: Value): void;
+    /**
+     * Gets all entries in the map.
+     *
+     * @returns An iterator over all entries in the map.
+     */
+    entries(): IterableIterator<readonly [key: Key, value: Value]>;
+    /**
+     * Gets a key by its value.
+     *
+     * @param value - The value.
+     * @returns The key.
+     */
+    getKey(value: Value): Key | undefined;
+    /**
+     * Gets a value by its key.
+     *
+     * @param key - The key.
+     * @returns The value.
+     */
+    getValue(key: Key): undefined | Value;
+    /**
+     * Checks if the map has a key.
+     *
+     * @param key - The key.
+     * @returns `true` if the map has the key, `false` otherwise.
+     */
+    hasKey(key: Key): boolean;
+    /**
+     * Checks if the map has a value.
+     *
+     * @param value - The value.
+     * @returns `true` if the map has the value, `false` otherwise.
+     */
+    hasValue(value: Value): boolean;
+    /**
+     * Gets all keys in the map.
+     *
+     * @returns An iterator over all keys in the map.
+     */
+    keys(): IterableIterator<Key>;
+    /**
+     * Sets a key-value pair in the map.
+     *
+     * @param key - The key.
+     * @param value - The value.
+     */
+    set(key: Key, value: Value): void;
+    /**
+     * Gets all values in the map.
+     *
+     * @returns An iterator over all values in the map.
+     */
+    values(): IterableIterator<Value>;
+}

package/dist/lib/esm/two-way-map.mjs

@@ -0,0 +1,126 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+class TwoWayMap {
+  keyValueMap = /* @__PURE__ */ new Map();
+  valueKeyMap = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new two-way map.
+   *
+   * @param entries - Entries to initialize the map with.
+   */
+  constructor(entries = []) {
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+  }
+  /**
+   * Clears the map.
+   */
+  clear() {
+    this.keyValueMap.clear();
+    this.valueKeyMap.clear();
+  }
+  /**
+   * Deletes a key from the map.
+   *
+   * @param key - The key.
+   */
+  deleteKey(key) {
+    const value = this.getValue(key);
+    if (value !== void 0) {
+      this.valueKeyMap.delete(value);
+    }
+    this.keyValueMap.delete(key);
+  }
+  /**
+   * Deletes a value from the map.
+   *
+   * @param value - The value.
+   */
+  deleteValue(value) {
+    const key = this.getKey(value);
+    if (key !== void 0) {
+      this.keyValueMap.delete(key);
+    }
+    this.valueKeyMap.delete(value);
+  }
+  /**
+   * Gets all entries in the map.
+   *
+   * @returns An iterator over all entries in the map.
+   */
+  entries() {
+    return this.keyValueMap.entries();
+  }
+  /**
+   * Gets a key by its value.
+   *
+   * @param value - The value.
+   * @returns The key.
+   */
+  getKey(value) {
+    return this.valueKeyMap.get(value);
+  }
+  /**
+   * Gets a value by its key.
+   *
+   * @param key - The key.
+   * @returns The value.
+   */
+  getValue(key) {
+    return this.keyValueMap.get(key);
+  }
+  /**
+   * Checks if the map has a key.
+   *
+   * @param key - The key.
+   * @returns `true` if the map has the key, `false` otherwise.
+   */
+  hasKey(key) {
+    return this.keyValueMap.has(key);
+  }
+  /**
+   * Checks if the map has a value.
+   *
+   * @param value - The value.
+   * @returns `true` if the map has the value, `false` otherwise.
+   */
+  hasValue(value) {
+    return this.valueKeyMap.has(value);
+  }
+  /**
+   * Gets all keys in the map.
+   *
+   * @returns An iterator over all keys in the map.
+   */
+  keys() {
+    return this.keyValueMap.keys();
+  }
+  /**
+   * Sets a key-value pair in the map.
+   *
+   * @param key - The key.
+   * @param value - The value.
+   */
+  set(key, value) {
+    this.deleteKey(key);
+    this.deleteValue(value);
+    this.keyValueMap.set(key, value);
+    this.valueKeyMap.set(value, key);
+  }
+  /**
+   * Gets all values in the map.
+   *
+   * @returns An iterator over all values in the map.
+   */
+  values() {
+    return this.valueKeyMap.keys();
+  }
+}
+export {
+  TwoWayMap
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/type-guards.d.mts

@@ -0,0 +1,84 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for type guards.
+ */
+/**
+ * A type that represents a generic object.
+ *
+ * @typeParam T - The base type to intersect with.
+ */
+export type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;
+type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+/**
+ * Asserts that a condition is `true`. Throws if it is not.
+ *
+ * Use in place of `/* v8 ignore *\/` for defensive guards that should
+ * never trigger at runtime but would otherwise create uncovered branches.
+ *
+ * @param isTrue - The condition to assert.
+ * @param errorOrMessage - The error or message to throw if the condition is `false`.
+ */
+export declare function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue;
+/**
+ * Asserts that a value is a generic object, narrowing its type in place.
+ *
+ * @typeParam T - The type of the value.
+ * @param _object - The value to assert.
+ */
+export declare function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T>;
+/**
+ * Asserts at compile time that every case of a discriminated union has been
+ * handled. Place at the `default` branch of a `switch` over a union or enum.
+ *
+ * If a new variant is added to the union without a matching `case`, the call
+ * to {@link assertNever} fails to compile because `value` is no longer `never`.
+ * If reached at runtime (e.g. because the value was bypassed via JSON or a
+ * type assertion), it throws a descriptive `Error`.
+ *
+ * @example
+ * ```ts
+ * switch (mode) {
+ *   case 'a': return doA();
+ *   case 'b': return doB();
+ *   default: assertNever(mode);
+ * }
+ * ```
+ *
+ * @param value - The exhaustively-handled value, narrowed to `never` by control flow.
+ * @throws Always, if reached at runtime.
+ */
+export declare function assertNever(value: never): never;
+/**
+ * Asserts that a value is not `null` or `undefined`, narrowing its type in place.
+ *
+ * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.
+ *
+ * @typeParam T - The type of the value.
+ * @param value - The value to check.
+ * @param errorOrMessage - Optional {@link Error} or error message string.
+ * @throws If the value is `null` or `undefined`.
+ */
+export declare function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T>;
+/**
+ * Ensures that a value is a generic object, returning it with narrowed type.
+ *
+ * @typeParam T - The type of the value.
+ * @param $object - The value to ensure.
+ * @returns The value as a generic object.
+ */
+export declare function ensureGenericObject<T>($object: T): GenericObject<T>;
+/**
+ * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.
+ *
+ * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.
+ *
+ * @typeParam T - The type of the value.
+ * @param value - The value to check.
+ * @param errorOrMessage - Optional {@link Error} or error message string.
+ * @returns The value with `null` and `undefined` excluded from its type.
+ * @throws If the value is `null` or `undefined`.
+ */
+export declare function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T>;
+export {};

package/dist/lib/esm/type-guards.mjs

@@ -0,0 +1,41 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { noop } from "./function.mjs";
+function assert(isTrue, errorOrMessage) {
+  if (!isTrue) {
+    throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  }
+}
+function assertGenericObject(_object) {
+  noop();
+}
+function assertNever(value) {
+  throw new Error(`Unhandled value: ${String(value)}`);
+}
+function assertNonNullable(value, errorOrMessage) {
+  if (value !== null && value !== void 0) {
+    return;
+  }
+  errorOrMessage ??= value === null ? "Value is null" : "Value is undefined";
+  const error = typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  throw error;
+}
+function ensureGenericObject($object) {
+  return $object;
+}
+function ensureNonNullable(value, errorOrMessage) {
+  assertNonNullable(value, errorOrMessage);
+  return value;
+}
+export {
+  assert,
+  assertGenericObject,
+  assertNever,
+  assertNonNullable,
+  ensureGenericObject,
+  ensureNonNullable
+};
+//# sourceMappingURL=data:application/json;base64,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