obsidian-dev-utils 17.10.0 → 17.10.2-beta.1

package/dist/lib/Object.mjs

@@ -0,0 +1,273 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import {
+  errorToString,
+  throwExpression
+} from "./Error.mjs";
+import { replaceAll } from "./String.mjs";
+var FunctionHandlingMode = /* @__PURE__ */ ((FunctionHandlingMode2) => {
+  FunctionHandlingMode2["Exclude"] = "exclude";
+  FunctionHandlingMode2["Full"] = "full";
+  FunctionHandlingMode2["NameOnly"] = "nameOnly";
+  return FunctionHandlingMode2;
+})(FunctionHandlingMode || {});
+function assignWithNonEnumerableProperties(target, ...sources) {
+  return _assignWithNonEnumerableProperties(target, ...sources);
+}
+function cloneWithNonEnumerableProperties(obj) {
+  return Object.create(getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  const aRecord = a;
+  const bRecord = b;
+  for (const key of keysA) {
+    if (!keysB.includes(key) || !deepEqual(aRecord[key], bRecord[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function deleteProperties(obj, propertyNames) {
+  let ans = false;
+  for (const propertyName of propertyNames) {
+    ans = deleteProperty(obj, propertyName) || ans;
+  }
+  return ans;
+}
+function deleteProperty(obj, propertyName) {
+  if (!Object.hasOwn(obj, propertyName)) {
+    return false;
+  }
+  delete obj[propertyName];
+  return true;
+}
+function getNestedPropertyValue(obj, path) {
+  let node = obj;
+  const keys = path.split(".");
+  for (const key of keys) {
+    if (node === void 0) {
+      return void 0;
+    }
+    node = node[key];
+  }
+  return node;
+}
+function getPrototypeOf(instance) {
+  if (instance === void 0 || instance === null) {
+    return instance;
+  }
+  return Object.getPrototypeOf(instance);
+}
+function nameof(name) {
+  return name;
+}
+function normalizeOptionalProperties(obj) {
+  return obj;
+}
+function setNestedPropertyValue(obj, path, value) {
+  const error = new Error(`Property path ${path} not found`);
+  let node = obj;
+  const keys = path.split(".");
+  for (const key of keys.slice(0, -1)) {
+    if (node === void 0) {
+      throw error;
+    }
+    node = node[key];
+  }
+  const lastKey = keys.at(-1);
+  if (node === void 0 || lastKey === void 0) {
+    throw error;
+  }
+  node[lastKey] = value;
+}
+function toJson(value, options = {}) {
+  const DEFAULT_OPTIONS = {
+    functionHandlingMode: "exclude" /* Exclude */,
+    maxDepth: -1,
+    shouldCatchToJSONErrors: false,
+    shouldHandleCircularReferences: false,
+    shouldHandleErrors: false,
+    shouldHandleUndefined: false,
+    shouldSortKeys: false,
+    // eslint-disable-next-line no-magic-numbers
+    space: 2,
+    tokenSubstitutions: {
+      circularReference: makeObjectTokenSubstitution("CircularReference" /* CircularReference */),
+      maxDepthLimitReached: makeObjectTokenSubstitution("MaxDepthLimitReached" /* MaxDepthLimitReached */),
+      toJSONFailed: makeObjectTokenSubstitution("ToJSONFailed" /* ToJSONFailed */)
+    }
+  };
+  const fullOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    tokenSubstitutions: {
+      ...DEFAULT_OPTIONS.tokenSubstitutions,
+      ...options.tokenSubstitutions
+    }
+  };
+  if (fullOptions.maxDepth === -1) {
+    fullOptions.maxDepth = Infinity;
+  }
+  const functionTexts = [];
+  const usedObjects = /* @__PURE__ */ new WeakSet();
+  const plainObject = toPlainObject(value, "", 0, true, fullOptions, functionTexts, usedObjects);
+  let json = JSON.stringify(plainObject, null, fullOptions.space) ?? "";
+  json = replaceAll(json, /"\[\[(?<Key>[A-Za-z]+)(?<Index>\d*)\]\]"/g, (_, key, indexStr) => applySubstitutions({
+    functionTexts,
+    index: indexStr ? parseInt(indexStr, 10) : 0,
+    key,
+    substitutions: fullOptions.tokenSubstitutions
+  }));
+  return json;
+}
+function _assignWithNonEnumerableProperties(target, ...sources) {
+  for (const source of sources) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  }
+  const sourcePrototypes = sources.map((source) => getPrototypeOf(source)).filter((proto) => !!proto);
+  if (sourcePrototypes.length > 0) {
+    const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);
+    Object.setPrototypeOf(target, targetPrototype);
+  }
+  return target;
+}
+function applySubstitutions(options) {
+  switch (options.key) {
+    case "CircularReference" /* CircularReference */:
+      return options.substitutions.circularReference;
+    case "Function" /* Function */:
+      return options.functionTexts[options.index] ?? throwExpression(new Error(`Function with index ${options.index.toString()} not found`));
+    case "MaxDepthLimitReached" /* MaxDepthLimitReached */:
+      return options.substitutions.maxDepthLimitReached;
+    case "MaxDepthLimitReachedArray" /* MaxDepthLimitReachedArray */:
+      return `Array(${options.index.toString()})`;
+    case "ToJSONFailed" /* ToJSONFailed */:
+      return options.substitutions.toJSONFailed;
+    case "Undefined" /* Undefined */:
+      return "undefined";
+    default:
+      break;
+  }
+}
+function handleArray(value, depth, canUseToJSON, fullOptions, functionTexts, usedObjects) {
+  if (depth > fullOptions.maxDepth) {
+    return makePlaceholder("MaxDepthLimitReachedArray" /* MaxDepthLimitReachedArray */, value.length);
+  }
+  return value.map((item, index) => toPlainObject(item, index.toString(), depth + 1, canUseToJSON, fullOptions, functionTexts, usedObjects));
+}
+function handleCircularReference(value, key, fullOptions) {
+  if (fullOptions.shouldHandleCircularReferences) {
+    return makePlaceholder("CircularReference" /* CircularReference */);
+  }
+  const valueConstructorName = value.constructor.name || "Object";
+  throw new TypeError(`Converting circular structure to JSON
+--> starting at object with constructor '${valueConstructorName}'
+--- property '${key}' closes the circle`);
+}
+function handleFunction(value, functionTexts, fullOptions) {
+  if (fullOptions.functionHandlingMode === "exclude" /* Exclude */) {
+    return void 0;
+  }
+  const index = functionTexts.length;
+  const functionText = fullOptions.functionHandlingMode === "full" /* Full */ ? value.toString() : `function ${value.name || "anonymous"}() { /* ... */ }`;
+  functionTexts.push(functionText);
+  return makePlaceholder("Function" /* Function */, index);
+}
+function handleObject(value, key, depth, canUseToJSON, fullOptions, functionTexts, usedObjects) {
+  if (usedObjects.has(value)) {
+    return handleCircularReference(value, key, fullOptions);
+  }
+  usedObjects.add(value);
+  if (canUseToJSON) {
+    const toJSONResult = tryHandleToJSON(value, key, depth, fullOptions, functionTexts, usedObjects);
+    if (toJSONResult !== void 0) {
+      return toJSONResult;
+    }
+  }
+  if (Array.isArray(value)) {
+    return handleArray(value, depth, canUseToJSON, fullOptions, functionTexts, usedObjects);
+  }
+  if (depth > fullOptions.maxDepth) {
+    return makePlaceholder("MaxDepthLimitReached" /* MaxDepthLimitReached */);
+  }
+  if (value instanceof Error && fullOptions.shouldHandleErrors) {
+    return errorToString(value);
+  }
+  return handlePlainObject(value, depth, canUseToJSON, fullOptions, functionTexts, usedObjects);
+}
+function handlePlainObject(value, depth, canUseToJSON, fullOptions, functionTexts, usedObjects) {
+  const entries = Object.entries(value);
+  if (fullOptions.shouldSortKeys) {
+    entries.sort(([key1], [key2]) => key1.localeCompare(key2));
+  }
+  return Object.fromEntries(
+    entries.map(([key2, value2]) => [
+      key2,
+      toPlainObject(value2, key2, depth + 1, canUseToJSON, fullOptions, functionTexts, usedObjects)
+    ])
+  );
+}
+function makeObjectTokenSubstitution(key) {
+  return `{ "[[${key}]]": null }`;
+}
+function makePlaceholder(key, index) {
+  return `[[${key}${index?.toString() ?? ""}]]`;
+}
+function toPlainObject(value, key, depth, canUseToJSON, fullOptions, functionTexts, usedObjects) {
+  if (value === void 0) {
+    return depth === 0 || fullOptions.shouldHandleUndefined ? makePlaceholder("Undefined" /* Undefined */) : void 0;
+  }
+  if (typeof value === "function") {
+    return handleFunction(value, functionTexts, fullOptions);
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  return handleObject(value, key, depth, canUseToJSON, fullOptions, functionTexts, usedObjects);
+}
+function tryHandleToJSON(value, key, depth, fullOptions, functionTexts, usedObjects) {
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function") {
+    try {
+      const newValue = toJSON.call(value, key);
+      return toPlainObject(newValue, key, depth, false, fullOptions, functionTexts, usedObjects);
+    } catch (e) {
+      if (fullOptions.shouldCatchToJSONErrors) {
+        return makePlaceholder("ToJSONFailed" /* ToJSONFailed */);
+      }
+      throw e;
+    }
+  }
+  return void 0;
+}
+export {
+  FunctionHandlingMode,
+  assignWithNonEnumerableProperties,
+  cloneWithNonEnumerableProperties,
+  deepEqual,
+  deleteProperties,
+  deleteProperty,
+  getNestedPropertyValue,
+  getPrototypeOf,
+  nameof,
+  normalizeOptionalProperties,
+  setNestedPropertyValue,
+  toJson
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Object.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Object\n * Contains utility functions for Objects.\n */\n\nimport type { UndefinedOnPartialDeep } from 'type-fest';\n\nimport {\n  errorToString,\n  throwExpression\n} from './Error.ts';\nimport { replaceAll } from './String.ts';\n\n/**\n * Specifies how functions should be handled in the JSON output.\n */\nexport enum FunctionHandlingMode {\n  /**\n   * Excludes functions from the JSON output.\n   */\n  Exclude = 'exclude',\n  /**\n   * Includes the full function definition in the JSON output.\n   */\n  Full = 'full',\n  /**\n   * Includes only the function name in the JSON output.\n   */\n  NameOnly = 'nameOnly'\n}\n\nenum TokenSubstitutionKey {\n  CircularReference = 'CircularReference',\n  Function = 'Function',\n  MaxDepthLimitReached = 'MaxDepthLimitReached',\n  MaxDepthLimitReachedArray = 'MaxDepthLimitReachedArray',\n  ToJSONFailed = 'ToJSONFailed',\n  Undefined = 'Undefined'\n}\n\n/**\n * Represents a constructor type for a given class `T` with arguments `Args`.\n *\n * @typeParam Type - The type of the instance being constructed.\n * @typeParam Args - The types of arguments the constructor accepts.\n */\nexport type Constructor<Type, Args extends unknown[] = []> = new (...args: Args) => Type;\n\n/**\n * Extracts the keys of a given type `Type` that match a specific value type `Value`.\n *\n * @typeParam Type - The type from which to extract the keys.\n * @typeParam Value - The value type to match against.\n */\nexport type KeysMatching<Type, Value> = { [Key in keyof Type]-?: Type[Key] extends Value ? Key : never }[keyof Type];\n\n/**\n * Options for converting an object to JSON.\n */\nexport interface ToJsonOptions {\n  /**\n   * Specifies how functions should be handled in the JSON output (default: `exclude`).\n   */\n  functionHandlingMode: FunctionHandlingMode;\n  /**\n   * Specifies the maximum depth of nested objects to include in the JSON output.\n   * Use `-1` for no limit.\n   * Defaults to `-1`.\n   */\n  maxDepth: number;\n  /**\n   * Specifies whether to catch errors in `toJSON()` and replace them with a placeholder.\n   * Defaults to `false`.\n   */\n  shouldCatchToJSONErrors: boolean;\n  /**\n   * Specifies whether to handle circular references in the JSON output.\n   * Defaults to `false`.\n   */\n  shouldHandleCircularReferences: boolean;\n  /**\n   * Specifies whether to handle errors in the JSON output.\n   * Defaults to `false`.\n   */\n  shouldHandleErrors: boolean;\n  /**\n   * Specifies whether to handle undefined values in the JSON output.\n   * Defaults to `false`.\n   */\n  shouldHandleUndefined: boolean;\n  /**\n   * Specifies whether to sort the keys of the JSON output.\n   * Defaults to `false`.\n   */\n  shouldSortKeys: boolean;\n  /**\n   * Specifies the indentation of the JSON output. This can be a number of spaces or a string. Defaults to `2`.\n   */\n  space: number | string;\n  /**\n   * Specifies the substitutions to use in the JSON output.\n   */\n  tokenSubstitutions: Partial<TokenSubstitutions>;\n}\n\ninterface ApplySubstitutionsOptions {\n  functionTexts: string[];\n  index: number;\n  key: TokenSubstitutionKey;\n  substitutions: TokenSubstitutions;\n}\n\ninterface JSONSerializable {\n  toJSON(...args: unknown[]): unknown;\n}\n\ninterface TokenSubstitutions {\n  circularReference: string;\n  maxDepthLimitReached: string;\n  toJSONFailed: string;\n}\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param source - The source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U>(target: T, source: U): T & U;\n\n/**\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V>(target: T, source1: U, source2: V): T & U & V;\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @param source3 - The third source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param sources - The source objects to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  return _assignWithNonEnumerableProperties(target, ...sources);\n}\n\n/**\n * Clones an object, including non-enumerable properties.\n *\n * @param obj - The object to clone.\n * @returns A new object with the same properties as the original object, including non-enumerable properties.\n */\nexport function cloneWithNonEnumerableProperties<T extends object>(obj: T): T {\n  return Object.create(getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)) as T;\n}\n\n/**\n * Compares two values to determine if they are deeply equal.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @returns `true` if the values are deeply equal, otherwise `false`.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {\n    return false;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  const aRecord = a as Record<string, unknown>;\n  const bRecord = b as Record<string, unknown>;\n\n  for (const key of keysA) {\n    if (!keysB.includes(key) || !deepEqual(aRecord[key], bRecord[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Deletes multiple properties from an object.\n *\n * @typeParam T - The type of the object.\n * @param obj - The object to delete the properties from.\n * @param propertyNames - The names of the properties to delete.\n * @returns `true` if any of the properties were present, otherwise `false`.\n */\nexport function deleteProperties<T extends object>(obj: T, propertyNames: (keyof T)[]): boolean {\n  let ans = false;\n\n  for (const propertyName of propertyNames) {\n    ans = deleteProperty(obj, propertyName) || ans;\n  }\n\n  return ans;\n}\n\n/**\n * Deletes a property from an object.\n *\n * @typeParam T - The type of the object.\n * @param obj - The object to delete the property from.\n * @param propertyName - The name of the property to delete.\n * @returns `true` if the property was present, otherwise `false`.\n */\nexport function deleteProperty<T extends object>(obj: T, propertyName: keyof T): boolean {\n  if (!Object.hasOwn(obj, propertyName)) {\n    return false;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n  delete obj[propertyName];\n  return true;\n}\n\n/**\n * Gets the value of a nested property from an object.\n *\n * @param obj - The object to get the nested property value from.\n * @param path - The path to the nested property.\n * @returns The value of the nested property.\n */\nexport function getNestedPropertyValue(obj: Record<string, unknown>, path: string): unknown {\n  let node: Record<string, unknown> | undefined = obj;\n  const keys = path.split('.');\n  for (const key of keys) {\n    if (node === undefined) {\n      return undefined;\n    }\n    node = node[key] as Record<string, unknown> | undefined;\n  }\n\n  return node;\n}\n\n/**\n * Gets the prototype of the specified object.\n *\n * @typeParam T - The type of the object.\n * @param instance - The object instance to retrieve the prototype of.\n * @returns The prototype of the object.\n */\nexport function getPrototypeOf<T>(instance: T): T {\n  if (instance === undefined || instance === null) {\n    return instance;\n  }\n  return Object.getPrototypeOf(instance) as T;\n}\n\n/**\n * Retrieves the name of a property of a given type `T`.\n *\n * @typeParam T - The type of the object containing the property.\n * @param name - The name of the property as a string.\n * @returns The name of the property.\n */\nexport function nameof<T>(name: Extract<keyof T, string>): string {\n  return name;\n}\n\n/**\n * Normalizes optional properties to allow `undefined` assignment in strict mode.\n *\n * This utility provides a workaround for the `exactOptionalPropertyTypes` TypeScript flag,\n * which prohibits directly assigning `undefined` to optional properties when the type\n * explicitly omits `undefined`.\n *\n * Example:\n * ```typescript\n * // With `exactOptionalPropertyTypes: true`\n * const x: { prop?: string } = { prop: undefined }; // Compiler error\n *\n * // Using this utility:\n * const y: { prop?: string } = normalizeOptionalProperties<{ prop?: string }>({ prop: undefined }); // Works\n * ```\n *\n * @typeParam T - The target type with optional properties to normalize.\n * @param obj - The object to normalize, allowing explicit `undefined` for optional properties.\n * @returns The normalized object, compatible with `exactOptionalPropertyTypes`.\n */\nexport function normalizeOptionalProperties<T>(obj: UndefinedOnPartialDeep<T>): T {\n  return obj as T;\n}\n\n/**\n * Sets the value of a nested property in an object.\n *\n * @param obj - The object to set the nested property value in.\n * @param path - The path to the nested property.\n * @param value - The value to set.\n */\nexport function setNestedPropertyValue(obj: Record<string, unknown>, path: string, value: unknown): void {\n  const error = new Error(`Property path ${path} not found`);\n  let node: Record<string, unknown> | undefined = obj;\n  const keys = path.split('.');\n  for (const key of keys.slice(0, -1)) {\n    if (node === undefined) {\n      throw error;\n    }\n    node = node[key] as Record<string, unknown> | undefined;\n  }\n\n  const lastKey = keys.at(-1);\n  if (node === undefined || lastKey === undefined) {\n    throw error;\n  }\n\n  node[lastKey] = value;\n}\n\n/**\n * Converts a given value to a JSON string.\n *\n * @param value - The value to be converted to JSON. This can be of any type.\n * @param options - Options for customizing the JSON conversion process.\n * @returns The JSON string representation of the input value.\n */\nexport function toJson(value: unknown, options: Partial<ToJsonOptions> = {}): string {\n  const DEFAULT_OPTIONS: { tokenSubstitutions: TokenSubstitutions } & ToJsonOptions = {\n    functionHandlingMode: FunctionHandlingMode.Exclude,\n    maxDepth: -1,\n    shouldCatchToJSONErrors: false,\n    shouldHandleCircularReferences: false,\n    shouldHandleErrors: false,\n    shouldHandleUndefined: false,\n    shouldSortKeys: false,\n    // eslint-disable-next-line no-magic-numbers\n    space: 2,\n    tokenSubstitutions: {\n      circularReference: makeObjectTokenSubstitution(TokenSubstitutionKey.CircularReference),\n      maxDepthLimitReached: makeObjectTokenSubstitution(TokenSubstitutionKey.MaxDepthLimitReached),\n      toJSONFailed: makeObjectTokenSubstitution(TokenSubstitutionKey.ToJSONFailed)\n    }\n  };\n\n  const fullOptions = {\n    ...DEFAULT_OPTIONS,\n    ...options,\n    tokenSubstitutions: {\n      ...DEFAULT_OPTIONS.tokenSubstitutions,\n      ...options.tokenSubstitutions\n    }\n  };\n\n  if (fullOptions.maxDepth === -1) {\n    fullOptions.maxDepth = Infinity;\n  }\n\n  const functionTexts: string[] = [];\n  const usedObjects = new WeakSet<object>();\n\n  const plainObject = toPlainObject(value, '', 0, true, fullOptions, functionTexts, usedObjects);\n  let json = JSON.stringify(plainObject, null, fullOptions.space) ?? '';\n  json = replaceAll(json, /\"\\[\\[(?<Key>[A-Za-z]+)(?<Index>\\d*)\\]\\]\"/g, (_, key, indexStr) =>\n    applySubstitutions({\n      functionTexts,\n      index: indexStr ? parseInt(indexStr, 10) : 0,\n      key: key as TokenSubstitutionKey,\n      substitutions: fullOptions.tokenSubstitutions\n    }));\n  return json;\n}\n\nfunction _assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  for (const source of sources) {\n    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n  }\n\n  const sourcePrototypes = (sources.map((source) => getPrototypeOf(source)) as (null | object)[]).filter<null | object>((proto) => !!proto) as object[];\n\n  if (sourcePrototypes.length > 0) {\n    const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);\n    Object.setPrototypeOf(target, targetPrototype);\n  }\n\n  return target;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type\nfunction applySubstitutions(options: ApplySubstitutionsOptions): string | void {\n  switch (options.key) {\n    case TokenSubstitutionKey.CircularReference:\n      return options.substitutions.circularReference;\n    case TokenSubstitutionKey.Function:\n      return options.functionTexts[options.index] ?? throwExpression(new Error(`Function with index ${options.index.toString()} not found`));\n    case TokenSubstitutionKey.MaxDepthLimitReached:\n      return options.substitutions.maxDepthLimitReached;\n    case TokenSubstitutionKey.MaxDepthLimitReachedArray:\n      return `Array(${options.index.toString()})`;\n    case TokenSubstitutionKey.ToJSONFailed:\n      return options.substitutions.toJSONFailed;\n    case TokenSubstitutionKey.Undefined:\n      return 'undefined';\n    default:\n      break;\n  }\n}\n\nfunction handleArray(\n  value: unknown[],\n  depth: number,\n  canUseToJSON: boolean,\n  fullOptions: ToJsonOptions,\n  functionTexts: string[],\n  usedObjects: WeakSet<object>\n): unknown {\n  if (depth > fullOptions.maxDepth) {\n    return makePlaceholder(TokenSubstitutionKey.MaxDepthLimitReachedArray, value.length);\n  }\n\n  return value.map((item, index) => toPlainObject(item, index.toString(), depth + 1, canUseToJSON, fullOptions, functionTexts, usedObjects));\n}\n\nfunction handleCircularReference(value: object, key: string, fullOptions: ToJsonOptions): unknown {\n  if (fullOptions.shouldHandleCircularReferences) {\n    return makePlaceholder(TokenSubstitutionKey.CircularReference);\n  }\n  const valueConstructorName = value.constructor.name || 'Object';\n  throw new TypeError(`Converting circular structure to JSON\n--> starting at object with constructor '${valueConstructorName}'\n--- property '${key}' closes the circle`);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nfunction handleFunction(value: Function, functionTexts: string[], fullOptions: ToJsonOptions): unknown {\n  if (fullOptions.functionHandlingMode === FunctionHandlingMode.Exclude) {\n    return undefined;\n  }\n  const index = functionTexts.length;\n  const functionText = fullOptions.functionHandlingMode === FunctionHandlingMode.Full\n    ? value.toString()\n    : `function ${value.name || 'anonymous'}() { /* ... */ }`;\n  functionTexts.push(functionText);\n  return makePlaceholder(TokenSubstitutionKey.Function, index);\n}\n\nfunction handleObject(\n  value: object,\n  key: string,\n  depth: number,\n  canUseToJSON: boolean,\n  fullOptions: ToJsonOptions,\n  functionTexts: string[],\n  usedObjects: WeakSet<object>\n): unknown {\n  if (usedObjects.has(value)) {\n    return handleCircularReference(value, key, fullOptions);\n  }\n\n  usedObjects.add(value);\n\n  if (canUseToJSON) {\n    const toJSONResult = tryHandleToJSON(value, key, depth, fullOptions, functionTexts, usedObjects);\n    if (toJSONResult !== undefined) {\n      return toJSONResult;\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return handleArray(value, depth, canUseToJSON, fullOptions, functionTexts, usedObjects);\n  }\n\n  if (depth > fullOptions.maxDepth) {\n    return makePlaceholder(TokenSubstitutionKey.MaxDepthLimitReached);\n  }\n\n  if (value instanceof Error && fullOptions.shouldHandleErrors) {\n    return errorToString(value);\n  }\n\n  return handlePlainObject(value, depth, canUseToJSON, fullOptions, functionTexts, usedObjects);\n}\n\nfunction handlePlainObject(\n  value: object,\n  depth: number,\n  canUseToJSON: boolean,\n  fullOptions: ToJsonOptions,\n  functionTexts: string[],\n  usedObjects: WeakSet<object>\n): unknown {\n  const entries = Object.entries(value);\n  if (fullOptions.shouldSortKeys) {\n    entries.sort(([key1], [key2]) => key1.localeCompare(key2));\n  }\n\n  return Object.fromEntries(\n    entries.map(([key2, value2]) => [\n      key2,\n      toPlainObject(value2, key2, depth + 1, canUseToJSON, fullOptions, functionTexts, usedObjects)\n    ])\n  );\n}\n\nfunction makeObjectTokenSubstitution(key: TokenSubstitutionKey): string {\n  return `{ \"[[${key}]]\": null }`;\n}\n\nfunction makePlaceholder(key: TokenSubstitutionKey, index?: number): string {\n  return `[[${key}${index?.toString() ?? ''}]]`;\n}\n\nfunction toPlainObject(\n  value: unknown,\n  key: string,\n  depth: number,\n  canUseToJSON: boolean,\n  fullOptions: ToJsonOptions,\n  functionTexts: string[],\n  usedObjects: WeakSet<object>\n): unknown {\n  if (value === undefined) {\n    return (depth === 0 || fullOptions.shouldHandleUndefined)\n      ? makePlaceholder(TokenSubstitutionKey.Undefined)\n      : undefined;\n  }\n\n  if (typeof value === 'function') {\n    return handleFunction(value, functionTexts, fullOptions);\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    return value;\n  }\n\n  return handleObject(value, key, depth, canUseToJSON, fullOptions, functionTexts, usedObjects);\n}\n\nfunction tryHandleToJSON(\n  value: object,\n  key: string,\n  depth: number,\n  fullOptions: ToJsonOptions,\n  functionTexts: string[],\n  usedObjects: WeakSet<object>\n): unknown {\n  const toJSON = (value as Partial<JSONSerializable>).toJSON;\n  if (typeof toJSON === 'function') {\n    try {\n      const newValue = toJSON.call(value, key);\n      return toPlainObject(newValue, key, depth, false, fullOptions, functionTexts, usedObjects);\n    } catch (e) {\n      if (fullOptions.shouldCatchToJSONErrors) {\n        return makePlaceholder(TokenSubstitutionKey.ToJSONFailed);\n      }\n      throw e;\n    }\n  }\n  return undefined;\n}\n"],
  "mappings": "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",
  "names": ["FunctionHandlingMode"]
}


package/dist/lib/Path.mjs

@@ -0,0 +1,76 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import pathBrowserify from "path-browserify";
+import {
+  ensureStartsWith,
+  replaceAll
+} from "./String.mjs";
+const WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\/[^:]*$/;
+const posix = pathBrowserify.posix;
+const delimiter = posix.delimiter;
+const sep = pathBrowserify.posix.sep;
+const basename = posix.basename;
+const dirname = posix.dirname;
+const extname = posix.extname;
+const format = posix.format;
+function isAbsolute(path) {
+  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;
+}
+const join = posix.join;
+const normalize = posix.normalize;
+const parse = posix.parse;
+const relative = posix.relative;
+function getDirname(importMetaUrl) {
+  return dirname(getFilename(importMetaUrl));
+}
+function getFilename(importMetaUrl) {
+  return resolve(new URL(importMetaUrl).pathname);
+}
+function makeFileName(fileName, extension) {
+  return extension ? `${fileName}.${extension}` : fileName;
+}
+function normalizeIfRelative(path) {
+  if (path.startsWith("/") || path.includes(":")) {
+    return path;
+  }
+  return ensureStartsWith(path, "./");
+}
+function resolve(...pathSegments) {
+  let path = posix.resolve(...pathSegments);
+  path = toPosixPath(path);
+  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);
+  return match?.[0] ?? path;
+}
+function toPosixBuffer(buffer) {
+  return Buffer.from(toPosixPath(buffer.toString()));
+}
+function toPosixPath(path) {
+  return replaceAll(path, "\\", "/");
+}
+export {
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  getDirname,
+  getFilename,
+  isAbsolute,
+  join,
+  makeFileName,
+  normalize,
+  normalizeIfRelative,
+  parse,
+  posix,
+  relative,
+  resolve,
+  sep,
+  toPosixBuffer,
+  toPosixPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Path.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Path\n * Contains utility functions for handling paths.\n */\n\nimport pathBrowserify from 'path-browserify';\n\nimport {\n  ensureStartsWith,\n  replaceAll\n} from './String.ts';\n\nconst WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\\/[^:]*$/;\n\n/**\n * Provides methods for handling POSIX paths.\n */\nexport const posix = pathBrowserify.posix;\n\n/**\n * The POSIX path delimiter.\n */\nexport const delimiter = posix.delimiter;\n\n/**\n * The POSIX segment separator.\n */\nexport const sep = pathBrowserify.posix.sep;\n\n/**\n * Returns the base name of a file, optionally removing the file extension.\n *\n * @param path - The path to get the base name from.\n * @param ext - An optional extension to remove from the base name.\n * @returns The base name of the file.\n */\nexport const basename = posix.basename;\n\n/**\n * Returns the directory name of a path.\n *\n * @param path - The path to get the directory name from.\n * @returns The directory name of the path.\n */\nexport const dirname = posix.dirname;\n\n/**\n * Returns the file extension of a path.\n *\n * @param path - The path to get the extension from.\n * @returns The file extension of the path.\n */\nexport const extname = posix.extname;\n\n/**\n * Formats a path object into a path string.\n *\n * @param pathObject - The path object to format.\n * @returns The formatted path string.\n */\nexport const format = posix.format;\n\n/**\n * Determines if a path is absolute.\n *\n * @param path - The path to check.\n * @returns `true` if the path is absolute, `false` otherwise.\n */\nexport function isAbsolute(path: string): boolean {\n  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;\n}\n\n/**\n * Joins multiple path segments into a single path.\n *\n * @param paths - The path segments to join.\n * @returns The joined path.\n */\nexport const join = posix.join;\n\n/**\n * Normalizes a path, resolving '..' and '.' segments.\n *\n * @param path - The path to normalize.\n * @returns The normalized path.\n */\nexport const normalize = posix.normalize;\n\n/**\n * Parses a path string into a path object.\n *\n * @param path - The path string to parse.\n * @returns The parsed path object.\n */\nexport const parse = posix.parse;\n\n/**\n * Returns the relative path from one path to another.\n *\n * @param from - The starting path.\n * @param to - The destination path.\n * @returns The relative path from `from` to `to`.\n */\nexport const relative = posix.relative;\n\n/**\n * Gets the directory name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the directory name.\n * @returns The POSIX-style directory name.\n */\nexport function getDirname(importMetaUrl: string): string {\n  return dirname(getFilename(importMetaUrl));\n}\n\n/**\n * Gets the filename from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the filename.\n * @returns The POSIX-style filename.\n */\nexport function getFilename(importMetaUrl: string): string {\n  return resolve(new URL(importMetaUrl).pathname);\n}\n\n/**\n * Makes a filename by appending an extension to a given filename.\n * If the extension is empty, the filename is returned as is.\n *\n * @param fileName - The filename to append the extension to.\n * @param extension - The extension to append to the filename.\n * @returns The filename with the extension appended.\n */\nexport function makeFileName(fileName: string, extension: string): string {\n  return extension ? `${fileName}.${extension}` : fileName;\n}\n\n/**\n * Normalizes a given path by ensuring it is relative, adding \"./\" if necessary.\n *\n * @param path - The path to normalize.\n * @returns The normalized path, starting with \"./\" if it was relative.\n */\nexport function normalizeIfRelative(path: string): string {\n  if (path.startsWith('/') || path.includes(':')) {\n    return path;\n  }\n\n  return ensureStartsWith(path, './');\n}\n\n/**\n * Resolves a sequence of paths or path segments into an absolute path.\n *\n * @param pathSegments - The sequence of path segments to resolve.\n * @returns The resolved absolute path.\n */\nexport function resolve(...pathSegments: string[]): string {\n  let path = posix.resolve(...pathSegments);\n  path = toPosixPath(path);\n  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);\n  return match?.[0] ?? path;\n}\n\n/**\n * Converts a buffer containing a path to a POSIX-style buffer by replacing backslashes with forward slashes.\n *\n * @param buffer - The buffer to convert.\n * @returns A new buffer containing the POSIX-style path.\n */\nexport function toPosixBuffer(buffer: Buffer): Buffer {\n  return Buffer.from(toPosixPath(buffer.toString()));\n}\n\n/**\n * Converts a given path to a POSIX-style path by replacing backslashes with forward slashes.\n *\n * @param path - The path to convert.\n * @returns The POSIX-style path.\n */\nexport function toPosixPath(path: string): string {\n  return replaceAll(path, '\\\\', '/');\n}\n"],
  "mappings": ";;;;;;;AAKA,OAAO,oBAAoB;AAE3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,MAAM,kCAAkC;AAKjC,MAAM,QAAQ,eAAe;AAK7B,MAAM,YAAY,MAAM;AAKxB,MAAM,MAAM,eAAe,MAAM;AASjC,MAAM,WAAW,MAAM;AAQvB,MAAM,UAAU,MAAM;AAQtB,MAAM,UAAU,MAAM;AAQtB,MAAM,SAAS,MAAM;AAQrB,SAAS,WAAW,MAAuB;AAChD,SAAO,MAAM,WAAW,IAAI,KAAK,gCAAgC,KAAK,IAAI,IAAI,CAAC,MAAM;AACvF;AAQO,MAAM,OAAO,MAAM;AAQnB,MAAM,YAAY,MAAM;AAQxB,MAAM,QAAQ,MAAM;AASpB,MAAM,WAAW,MAAM;AAQvB,SAAS,WAAW,eAA+B;AACxD,SAAO,QAAQ,YAAY,aAAa,CAAC;AAC3C;AAQO,SAAS,YAAY,eAA+B;AACzD,SAAO,QAAQ,IAAI,IAAI,aAAa,EAAE,QAAQ;AAChD;AAUO,SAAS,aAAa,UAAkB,WAA2B;AACxE,SAAO,YAAY,GAAG,QAAQ,IAAI,SAAS,KAAK;AAClD;AAQO,SAAS,oBAAoB,MAAsB;AACxD,MAAI,KAAK,WAAW,GAAG,KAAK,KAAK,SAAS,GAAG,GAAG;AAC9C,WAAO;AAAA,EACT;AAEA,SAAO,iBAAiB,MAAM,IAAI;AACpC;AAQO,SAAS,WAAW,cAAgC;AACzD,MAAI,OAAO,MAAM,QAAQ,GAAG,YAAY;AACxC,SAAO,YAAY,IAAI;AACvB,QAAM,QAAQ,gCAAgC,KAAK,IAAI;AACvD,SAAO,QAAQ,CAAC,KAAK;AACvB;AAQO,SAAS,cAAc,QAAwB;AACpD,SAAO,OAAO,KAAK,YAAY,OAAO,SAAS,CAAC,CAAC;AACnD;AAQO,SAAS,YAAY,MAAsB;AAChD,SAAO,WAAW,MAAM,MAAM,GAAG;AACnC;",
  "names": []
}


package/dist/lib/RegExp.mjs

@@ -0,0 +1,23 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+function escapeRegExp(str) {
+  return str.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isValidRegExp(str) {
+  try {
+    new RegExp(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  escapeRegExp,
+  isValidRegExp
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL1JlZ0V4cC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb24gUmVnRXhwXG4gKiBDb250YWlucyB1dGlsaXR5IGZ1bmN0aW9ucyBmb3IgcmVndWxhciBleHByZXNzaW9ucy5cbiAqL1xuXG4vKipcbiAqIEVzY2FwZXMgc3BlY2lhbCBjaGFyYWN0ZXJzIGluIGEgc3RyaW5nIHRvIHNhZmVseSB1c2UgaXQgd2l0aGluIGEgcmVndWxhciBleHByZXNzaW9uLlxuICpcbiAqIEBwYXJhbSBzdHIgLSBUaGUgc3RyaW5nIHRvIGVzY2FwZS5cbiAqIEByZXR1cm5zIFRoZSBlc2NhcGVkIHN0cmluZyB3aXRoIHNwZWNpYWwgY2hhcmFjdGVycyBwcmVmaXhlZCB3aXRoIGEgYmFja3NsYXNoLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZXNjYXBlUmVnRXhwKHN0cjogc3RyaW5nKTogc3RyaW5nIHtcbiAgLy8gTk9URTogV2UgY2FuJ3QgdXNlIGByZXBsYWNlQWxsKClgIGZyb20gYFN0cmluZy50c2AgaGVyZSBiZWNhdXNlIGl0IGludHJvZHVjZXMgYSBjaXJjdWxhciBkZXBlbmRlbmN5LlxuICByZXR1cm4gc3RyLnJlcGxhY2VBbGwoL1suKis/XiR7fSgpfFtcXF1cXFxcXS9nLCAnXFxcXCQmJyk7XG59XG5cbi8qKlxuICogQ2hlY2tzIGlmIGEgc3RyaW5nIGlzIGEgdmFsaWQgcmVndWxhciBleHByZXNzaW9uLlxuICpcbiAqIEBwYXJhbSBzdHIgLSBUaGUgc3RyaW5nIHRvIGNoZWNrLlxuICogQHJldHVybnMgYHRydWVgIGlmIHRoZSBzdHJpbmcgaXMgYSB2YWxpZCByZWd1bGFyIGV4cHJlc3Npb24sIGBmYWxzZWAgb3RoZXJ3aXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNWYWxpZFJlZ0V4cChzdHI6IHN0cmluZyk6IGJvb2xlYW4ge1xuICB0cnkge1xuICAgIG5ldyBSZWdFeHAoc3RyKTtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfSBjYXRjaCB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7O0FBV08sU0FBUyxhQUFhLEtBQXFCO0FBRWhELFNBQU8sSUFBSSxXQUFXLHVCQUF1QixNQUFNO0FBQ3JEO0FBUU8sU0FBUyxjQUFjLEtBQXNCO0FBQ2xELE1BQUk7QUFDRixRQUFJLE9BQU8sR0FBRztBQUNkLFdBQU87QUFBQSxFQUNULFFBQVE7QUFDTixXQUFPO0FBQUEsRUFDVDtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/String.mjs

@@ -0,0 +1,119 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import { throwExpression } from "./Error.mjs";
+import { escapeRegExp } from "./RegExp.mjs";
+import { resolveValue } from "./ValueProvider.mjs";
+const ESCAPE_MAP = {
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t",
+  "\b": "\\b",
+  "\f": "\\f",
+  "'": "\\'",
+  '"': '\\"',
+  "\\": "\\\\"
+};
+const UNESCAPE_MAP = {};
+for (const [key, value] of Object.entries(ESCAPE_MAP)) {
+  UNESCAPE_MAP[value] = key;
+}
+function ensureEndsWith(str, suffix) {
+  return str.endsWith(suffix) ? str : str + suffix;
+}
+function ensureStartsWith(str, prefix) {
+  return str.startsWith(prefix) ? str : prefix + str;
+}
+function escape(str) {
+  return replace(str, ESCAPE_MAP);
+}
+function insertAt(str, substring, startIndex, endIndex) {
+  endIndex ??= startIndex;
+  return str.slice(0, startIndex) + substring + str.slice(endIndex);
+}
+function makeValidVariableName(str) {
+  return replaceAll(str, /[^a-zA-Z0-9_]/g, "_");
+}
+function normalize(str) {
+  return replaceAll(str, /\u00A0|\u202F/g, " ").normalize("NFC");
+}
+function replace(str, replacementsMap) {
+  const regExp = new RegExp(Object.keys(replacementsMap).map((source) => escapeRegExp(source)).join("|"), "g");
+  return replaceAll(str, regExp, ({ substring: source }) => replacementsMap[source] ?? throwExpression(new Error(`Unexpected replacement source: ${source}`)));
+}
+function replaceAll(str, searchValue, replacer) {
+  if (typeof replacer === "undefined") {
+    return str;
+  }
+  if (searchValue instanceof RegExp && !searchValue.global) {
+    searchValue = new RegExp(searchValue.source, `${searchValue.flags}g`);
+  }
+  if (typeof replacer === "string") {
+    return str.replaceAll(searchValue, replacer);
+  }
+  return str.replaceAll(searchValue, (substring, ...args) => {
+    const SOURCE_INDEX_OFFSET_FOR_GROUP_ARG = 2;
+    const hasGroupsArg = typeof args.at(-1) === "object";
+    const sourceIndex = hasGroupsArg ? args.length - SOURCE_INDEX_OFFSET_FOR_GROUP_ARG : args.length - 1;
+    const commonArgs = {
+      groups: hasGroupsArg ? args.at(-1) : void 0,
+      offset: args.at(sourceIndex - 1),
+      source: args.at(sourceIndex),
+      substring
+    };
+    const groupArgs = args.slice(0, sourceIndex - 1);
+    return replacer(commonArgs, ...groupArgs) ?? commonArgs.substring;
+  });
+}
+async function replaceAllAsync(str, searchValue, replacer) {
+  if (typeof replacer === "string") {
+    return replaceAll(str, searchValue, replacer);
+  }
+  const replacementPromises = [];
+  replaceAll(str, searchValue, (commonArgs, ...groupArgs) => {
+    replacementPromises.push(resolveValue(replacer, commonArgs, ...groupArgs));
+    return "";
+  });
+  const replacements = await Promise.all(replacementPromises);
+  return replaceAll(str, searchValue, (args) => replacements.shift() ?? args.substring);
+}
+function trimEnd(str, suffix, shouldValidate) {
+  if (str.endsWith(suffix)) {
+    return str.slice(0, -suffix.length);
+  }
+  if (shouldValidate) {
+    throw new Error(`String ${str} does not end with suffix ${suffix}`);
+  }
+  return str;
+}
+function trimStart(str, prefix, validate) {
+  if (str.startsWith(prefix)) {
+    return str.slice(prefix.length);
+  }
+  if (validate) {
+    throw new Error(`String ${str} does not start with prefix ${prefix}`);
+  }
+  return str;
+}
+function unescape(str) {
+  return replace(str, UNESCAPE_MAP);
+}
+export {
+  ensureEndsWith,
+  ensureStartsWith,
+  escape,
+  insertAt,
+  makeValidVariableName,
+  normalize,
+  replace,
+  replaceAll,
+  replaceAllAsync,
+  trimEnd,
+  trimStart,
+  unescape
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/String.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation String\n * Contains utility functions for string operations.\n */\n\nimport type { ValueProvider } from './ValueProvider.ts';\n\nimport { throwExpression } from './Error.ts';\nimport { escapeRegExp } from './RegExp.ts';\nimport { resolveValue } from './ValueProvider.ts';\n\n/**\n * A synchronous/asynchronous function that generates replacement strings, or a string to replace with.\n */\nexport type AsyncReplacer<ReplaceGroupArgs extends string[]> = ValueProvider<StringReplacement, [ReplaceCommonArgs, ...ReplaceGroupArgs]>;\n\n/**\n * Common arguments for the `replaceAll`/`replaceAllAsync` functions.\n */\nexport interface ReplaceCommonArgs {\n  /**\n   * The groups of the match.\n   */\n  groups: Record<string, string | undefined> | undefined;\n\n  /**\n   * The offset of the match.\n   */\n  offset: number;\n\n  /**\n   * The source of the match.\n   */\n  source: string;\n\n  /**\n   * The substring of the match.\n   */\n  substring: string;\n}\n\n/**\n * A synchronous function that generates replacement strings, or a string to replace with.\n */\nexport type Replacer<ReplaceGroupArgs extends string[]> = ((...args: [ReplaceCommonArgs, ...ReplaceGroupArgs]) => StringReplacement) | StringReplacement;\n\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type\ntype StringReplacement = string | void;\n\n/**\n * Mapping of special characters to their escaped counterparts.\n */\nconst ESCAPE_MAP: Record<string, string> = {\n  '\\n': '\\\\n',\n  '\\r': '\\\\r',\n  '\\t': '\\\\t',\n  '\\b': '\\\\b',\n  '\\f': '\\\\f',\n  '\\'': '\\\\\\'',\n  '\"': '\\\\\"',\n  '\\\\': '\\\\\\\\'\n} as const;\n\n/**\n * Mapping of escaped special characters to their unescaped counterparts.\n */\nconst UNESCAPE_MAP: Record<string, string> = {};\nfor (const [key, value] of Object.entries(ESCAPE_MAP)) {\n  UNESCAPE_MAP[value] = key;\n}\n\n/**\n * Ensures that a string ends with the specified suffix, adding it if necessary.\n *\n * @param str - The string to check.\n * @param suffix - The suffix to ensure.\n * @returns The string that ends with the suffix.\n */\nexport function ensureEndsWith(str: string, suffix: string): string {\n  return str.endsWith(suffix) ? str : str + suffix;\n}\n\n/**\n * Ensures that a string starts with the specified prefix, adding it if necessary.\n *\n * @param str - The string to check.\n * @param prefix - The prefix to ensure.\n * @returns The string that starts with the prefix.\n */\nexport function ensureStartsWith(str: string, prefix: string): string {\n  return str.startsWith(prefix) ? str : prefix + str;\n}\n\n/**\n * Escapes special characters in a string.\n *\n * @param str - The string to escape.\n * @returns The escaped string.\n */\nexport function escape(str: string): string {\n  return replace(str, ESCAPE_MAP);\n}\n\n/**\n * Inserts a substring at a specified position in a string.\n *\n * @param str - The string to insert the substring into.\n * @param substring - The substring to insert.\n * @param startIndex - The index to insert the substring at.\n * @param endIndex - The index to end the substring at.\n * @returns The modified string with the substring inserted.\n */\nexport function insertAt(str: string, substring: string, startIndex: number, endIndex?: number): string {\n  endIndex ??= startIndex;\n  return str.slice(0, startIndex) + substring + str.slice(endIndex);\n}\n\n/**\n * Converts a string into a valid JavaScript variable name by replacing invalid characters with underscores.\n *\n * @param str - The string to convert.\n * @returns The valid variable name.\n */\nexport function makeValidVariableName(str: string): string {\n  return replaceAll(str, /[^a-zA-Z0-9_]/g, '_');\n}\n\n/**\n * Normalizes a string by converting it to the NFC form and replacing non-breaking spaces with regular spaces.\n *\n * @param str - The string to normalize.\n * @returns The normalized string.\n */\nexport function normalize(str: string): string {\n  return replaceAll(str, /\\u00A0|\\u202F/g, ' ').normalize('NFC');\n}\n\n/**\n * Replaces occurrences of strings in a given string based on a replacements map.\n *\n * @param str - The string to perform replacements on.\n * @param replacementsMap - An object mapping strings to their replacement values.\n * @returns The modified string with replacements applied.\n */\nexport function replace(str: string, replacementsMap: Record<string, string>): string {\n  const regExp = new RegExp(Object.keys(replacementsMap).map((source) => escapeRegExp(source)).join('|'), 'g');\n  return replaceAll(str, regExp, ({ substring: source }) => replacementsMap[source] ?? throwExpression(new Error(`Unexpected replacement source: ${source}`)));\n}\n\n/**\n * Replaces all occurrences of a search string or pattern with the results of an replacer function.\n *\n * @typeParam ReplaceGroupArgs - The type of additional arguments passed to the replacer function.\n * @param str - The string in which to perform replacements.\n * @param searchValue - The string or regular expression to search for.\n * @param replacer - A replacer function that generates replacement strings, or a string to replace with.\n * @returns The string with all replacements made.\n */\nexport function replaceAll<ReplaceGroupArgs extends string[]>(\n  str: string,\n  searchValue: RegExp | string,\n  replacer: Replacer<ReplaceGroupArgs>\n): string {\n  if (typeof replacer === 'undefined') {\n    return str;\n  }\n\n  if (searchValue instanceof RegExp && !searchValue.global) {\n    searchValue = new RegExp(searchValue.source, `${searchValue.flags}g`);\n  }\n\n  if (typeof replacer === 'string') {\n    return str.replaceAll(searchValue, replacer);\n  }\n\n  return str.replaceAll(searchValue, (substring: string, ...args: unknown[]) => {\n    const SOURCE_INDEX_OFFSET_FOR_GROUP_ARG = 2;\n    const hasGroupsArg = typeof args.at(-1) === 'object';\n    const sourceIndex = hasGroupsArg ? args.length - SOURCE_INDEX_OFFSET_FOR_GROUP_ARG : args.length - 1;\n\n    const commonArgs: ReplaceCommonArgs = {\n      groups: hasGroupsArg ? args.at(-1) as Record<string, string | undefined> : undefined,\n      offset: args.at(sourceIndex - 1) as number,\n      source: args.at(sourceIndex) as string,\n      substring\n    };\n\n    const groupArgs = args.slice(0, sourceIndex - 1) as ReplaceGroupArgs;\n    return (replacer(commonArgs, ...groupArgs) as string | undefined) ?? commonArgs.substring;\n  });\n}\n\n/**\n * Asynchronously replaces all occurrences of a search string or pattern with the results of an asynchronous replacer function.\n *\n * @typeParam ReplaceGroupArgs - The type of additional arguments passed to the replacer function.\n * @param str - The string in which to perform replacements.\n * @param searchValue - The string or regular expression to search for.\n * @param replacer - A synchronous/asynchronous function that generates replacement strings, or a string to replace with.\n * @returns A promise that resolves to the string with all replacements made.\n */\nexport async function replaceAllAsync<ReplaceGroupArgs extends string[]>(\n  str: string,\n  searchValue: RegExp | string,\n  replacer: AsyncReplacer<ReplaceGroupArgs>\n): Promise<string> {\n  if (typeof replacer === 'string') {\n    return replaceAll(str, searchValue, replacer);\n  }\n\n  const replacementPromises: Promise<StringReplacement>[] = [];\n\n  replaceAll<ReplaceGroupArgs>(str, searchValue, (commonArgs, ...groupArgs) => {\n    replacementPromises.push(resolveValue(replacer, commonArgs, ...groupArgs));\n    return '';\n  });\n\n  const replacements = await Promise.all(replacementPromises);\n  return replaceAll(str, searchValue, (args): string => replacements.shift() ?? args.substring);\n}\n\n/**\n * Trims the specified suffix from the end of a string.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove from the end of the string.\n * @param shouldValidate - If true, throws an error if the string does not end with the suffix.\n * @returns The trimmed string.\n * @throws If `validate` is true and the string does not end with the suffix.\n */\nexport function trimEnd(str: string, suffix: string, shouldValidate?: boolean): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n\n  if (shouldValidate) {\n    throw new Error(`String ${str} does not end with suffix ${suffix}`);\n  }\n\n  return str;\n}\n\n/**\n * Trims the specified prefix from the start of a string.\n *\n * @param str - The string to trim.\n * @param prefix - The prefix to remove from the start of the string.\n * @param validate - If true, throws an error if the string does not start with the prefix.\n * @returns The trimmed string.\n * @throws If `validate` is true and the string does not start with the prefix.\n */\nexport function trimStart(str: string, prefix: string, validate?: boolean): string {\n  if (str.startsWith(prefix)) {\n    return str.slice(prefix.length);\n  }\n\n  if (validate) {\n    throw new Error(`String ${str} does not start with prefix ${prefix}`);\n  }\n\n  return str;\n}\n\n/**\n * Unescapes a string by replacing escape sequences with their corresponding characters.\n *\n * @param str - The string to unescape.\n * @returns The unescaped string.\n */\nexport function unescape(str: string): string {\n  return replace(str, UNESCAPE_MAP);\n}\n"],
  "mappings": "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",
  "names": []
}
