obsidian-dev-utils 49.0.3 → 51.0.1

package/dist/lib/esm/object-utils.mjs

@@ -0,0 +1,435 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { errorToString } from "./error.mjs";
+import { replaceAll } from "./string.mjs";
+import {
+  ensureGenericObject,
+  ensureNonNullable
+} from "./type-guards.mjs";
+var FunctionHandlingMode = /* @__PURE__ */ ((FunctionHandlingMode2) => {
+  FunctionHandlingMode2["Exclude"] = "exclude";
+  FunctionHandlingMode2["Full"] = "full";
+  FunctionHandlingMode2["NameOnly"] = "nameOnly";
+  return FunctionHandlingMode2;
+})(FunctionHandlingMode || {});
+const KEY_SEPARATOR = ".";
+const equalityComparerEntries = createEqualityComparerEntries(
+  [
+    { constructor: ArrayBuffer, equalityComparer: deepEqualArrayBuffer },
+    { constructor: Date, equalityComparer: deepEqualDate },
+    { constructor: RegExp, equalityComparer: deepEqualRegExp },
+    { constructor: Map, equalityComparer: deepEqualMap },
+    { constructor: Set, equalityComparer: deepEqualSet }
+  ]
+);
+function assignWithNonEnumerableProperties(target, ...sources) {
+  return _assignWithNonEnumerableProperties(target, ...sources);
+}
+function castTo(value) {
+  return value;
+}
+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 aConstructor = a.constructor;
+  const bConstructor = b.constructor;
+  if (aConstructor !== bConstructor) {
+    return false;
+  }
+  if (aConstructor !== Object) {
+    const result = deepEqualTyped(a, b);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  const keysA = getAllKeys(a);
+  const keysB = getAllKeys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  const aRecord = ensureGenericObject(a);
+  const bRecord = ensureGenericObject(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 extractDefaultExportInterop(module) {
+  if (typeof module !== "object" || module === null) {
+    return module;
+  }
+  if ("default" in module) {
+    return module.default;
+  }
+  return module;
+}
+function getAllEntries(obj) {
+  return getAllKeys(obj).map((key) => [key, obj[key]]);
+}
+function getAllKeys(obj) {
+  const keys = [];
+  let current = obj;
+  while (current) {
+    const descriptors = Object.getOwnPropertyDescriptors(current);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (key === "__proto__") {
+        continue;
+      }
+      if (typeof descriptor.value === "function") {
+        continue;
+      }
+      const hasGetter = typeof descriptor.get === "function";
+      const hasSetter = typeof descriptor.set === "function";
+      if (hasGetter || hasSetter) {
+        if (hasGetter && hasSetter) {
+          keys.push(key);
+        }
+        continue;
+      }
+      if (descriptor.enumerable && descriptor.writable) {
+        keys.push(key);
+      }
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return keys.sort();
+}
+function getNestedPropertyValue(obj, path) {
+  let node = obj;
+  const keys = path.split(KEY_SEPARATOR);
+  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 removeUndefinedProperties(obj, keysToKeep) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 && !keysToKeep?.includes(key)) {
+      delete obj[key];
+    }
+  }
+  return obj;
+}
+function setNestedPropertyValue(obj, path, value) {
+  const error = new Error(`Property path ${path} not found`);
+  let node = obj;
+  const keys = path.split(KEY_SEPARATOR);
+  for (const key of keys.slice(0, -1)) {
+    if (node === void 0) {
+      throw error;
+    }
+    node = node[key];
+  }
+  const lastKey = ensureNonNullable(keys.at(-1));
+  if (node === 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 -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.
+    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 = ensureNonNullable(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) {
+    const descriptors = Object.getOwnPropertyDescriptors(source);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      try {
+        if (key === "prototype" || Object.getOwnPropertyDescriptor(target, key)?.writable === false && !Object.getOwnPropertyDescriptor(target, key)?.configurable) {
+          continue;
+        }
+        Object.defineProperty(target, key, descriptor);
+      } catch {
+      }
+    }
+  }
+  const sourcePrototypes = sources.map((source) => getPrototypeOf(source)).filter((proto) => !!proto);
+  if (sourcePrototypes.length > 0) {
+    const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);
+    try {
+      Object.setPrototypeOf(target, targetPrototype);
+    } catch {
+    }
+  }
+  return target;
+}
+function applySubstitutions(params) {
+  switch (params.key) {
+    /* v8 ignore stop */
+    case "CircularReference" /* CircularReference */:
+      return params.substitutions.circularReference;
+    case "Function" /* Function */:
+      return ensureNonNullable(params.functionTexts[params.index], `Function with index ${String(params.index)} not found`);
+    case "MaxDepthLimitReached" /* MaxDepthLimitReached */:
+      return params.substitutions.maxDepthLimitReached;
+    case "MaxDepthLimitReachedArray" /* MaxDepthLimitReachedArray */:
+      return `Array(${String(params.index)})`;
+    case "ToJSONFailed" /* ToJSONFailed */:
+      return params.substitutions.toJSONFailed;
+    case "Undefined" /* Undefined */:
+      return "undefined";
+    default:
+      break;
+  }
+}
+function createEqualityComparerEntries(entries) {
+  return entries;
+}
+function deepEqualArrayBuffer(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const viewA = new Uint8Array(a);
+  const viewB = new Uint8Array(b);
+  return deepEqual(viewA, viewB);
+}
+function deepEqualDate(a, b) {
+  return a.getTime() === b.getTime();
+}
+function deepEqualMap(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const [key, value] of a.entries()) {
+    if (!b.has(key) || !deepEqual(value, b.get(key))) {
+      return false;
+    }
+  }
+  return true;
+}
+function deepEqualRegExp(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+function deepEqualSet(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const valueA of a) {
+    if (b.has(valueA)) {
+      continue;
+    }
+    let found = false;
+    for (const valueB of b) {
+      if (deepEqual(valueA, valueB)) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      return false;
+    }
+  }
+  return true;
+}
+function deepEqualTyped(a, b) {
+  for (const { constructor, equalityComparer } of equalityComparerEntries) {
+    if (a instanceof constructor && b instanceof constructor) {
+      return equalityComparer(a, b);
+    }
+  }
+  return void 0;
+}
+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, String(index), 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 */ ? String(value) : `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 ? String(index) : ""}]]`;
+}
+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,
+  castTo,
+  cloneWithNonEnumerableProperties,
+  deepEqual,
+  deleteProperties,
+  deleteProperty,
+  extractDefaultExportInterop,
+  getAllEntries,
+  getAllKeys,
+  getNestedPropertyValue,
+  getPrototypeOf,
+  nameof,
+  normalizeOptionalProperties,
+  removeUndefinedProperties,
+  setNestedPropertyValue,
+  toJson
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/object-utils.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for Objects.\n */\n\nimport type {\n  Constructor,\n  RequiredKeysOf,\n  UndefinedOnPartialDeep\n} from 'type-fest';\n\nimport type { GenericObject } from './type-guards.ts';\nimport type {\n  ExactMembers,\n  MaybeReturn,\n  StringKeys\n} from './type.ts';\n\nimport { errorToString } from './error.ts';\nimport { replaceAll } from './string.ts';\nimport {\n  ensureGenericObject,\n  ensureNonNullable\n} from './type-guards.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 * Options for {@link toJson}.\n */\nexport interface ToJsonOptions {\n  /**\n   * Specifies how functions should be handled in the JSON output (default: `exclude`).\n   */\n  readonly functionHandlingMode: FunctionHandlingMode;\n\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  readonly maxDepth: number;\n\n  /**\n   * Specifies whether to catch errors in `toJSON()` and replace them with a placeholder.\n   * Defaults to `false`.\n   */\n  readonly shouldCatchToJSONErrors: boolean;\n\n  /**\n   * Specifies whether to handle circular references in the JSON output.\n   * Defaults to `false`.\n   */\n  readonly shouldHandleCircularReferences: boolean;\n\n  /**\n   * Specifies whether to handle errors in the JSON output.\n   * Defaults to `false`.\n   */\n  readonly shouldHandleErrors: boolean;\n\n  /**\n   * Specifies whether to handle `undefined` values in the JSON output.\n   * Defaults to `false`.\n   */\n  readonly shouldHandleUndefined: boolean;\n\n  /**\n   * Specifies whether to sort the keys of the JSON output.\n   * Defaults to `false`.\n   */\n  readonly shouldSortKeys: boolean;\n\n  /**\n   * Specifies the indentation of the JSON output. This can be a number of spaces or a string. Defaults to `2`.\n   */\n  readonly space: number | string;\n\n  /**\n   * Specifies the substitutions to use in the JSON output.\n   */\n  readonly tokenSubstitutions: Partial<TokenSubstitutions>;\n}\n\ninterface ApplySubstitutionsParams {\n  readonly functionTexts: readonly string[];\n  readonly index: number;\n  readonly key: TokenSubstitutionKey;\n  readonly substitutions: TokenSubstitutions;\n}\n\ninterface EqualityComparerEntry<T> {\n  constructor: Constructor<T>;\n  equalityComparer(a: T, b: T): boolean;\n}\n\ninterface JSONSerializable {\n  toJSON(...args: unknown[]): unknown;\n}\n\ninterface ModuleWithDefaultExport<T> {\n  default: T;\n}\n\ninterface TokenSubstitutions {\n  circularReference: string;\n  maxDepthLimitReached: string;\n  toJSONFailed: string;\n}\n\nconst KEY_SEPARATOR = '.';\nconst equalityComparerEntries = createEqualityComparerEntries(\n  [\n    { constructor: ArrayBuffer, equalityComparer: deepEqualArrayBuffer },\n    { constructor: Date, equalityComparer: deepEqualDate },\n    { constructor: RegExp, equalityComparer: deepEqualRegExp },\n    { constructor: Map, equalityComparer: deepEqualMap },\n    { constructor: Set, equalityComparer: deepEqualSet }\n  ] as const\n);\n\ntype KeysWithUndefined<T> = {\n  [K in keyof T]-?: undefined extends T[K] ? K : never;\n}[keyof T];\n\ntype MandatoryKeysWithUndefined<T extends object> = Extract<RequiredKeysOf<T> & StringKeys<T>, KeysWithUndefined<T>>;\n\ntype RemoveUndefinedOverload<T extends object> = MandatoryKeysWithUndefined<T> extends never ? [obj: T]\n  : never;\n\ntype RemoveUndefinedWithKeysOverload<T extends object, K extends readonly string[]> = [obj: T, keysToKeep: ExactMembers<MandatoryKeysWithUndefined<T>, K>];\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 * @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 * 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 * 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 * Casts a value to a specific type.\n *\n * @param value - The value to cast.\n * @returns The value as the specified type.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to cast.\nexport function castTo<T>(value: unknown): T {\n  return value as T;\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 * 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 aConstructor = a.constructor;\n  const bConstructor = b.constructor;\n\n  if (aConstructor !== bConstructor) {\n    return false;\n  }\n\n  if (aConstructor !== Object) {\n    const result = deepEqualTyped(a, b);\n    if (result !== undefined) {\n      return result;\n    }\n  }\n\n  const keysA = getAllKeys(a);\n  const keysB = getAllKeys(b);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  const aRecord = ensureGenericObject(a);\n  const bRecord = ensureGenericObject(b);\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 -- We have no other way to delete the property.\n  delete obj[propertyName];\n  return true;\n}\n\n/**\n * Extracts the default export from a module.\n *\n * Useful to handle incorrect default export interop between ESM and CJS.\n *\n * @param module - The module to extract the default export from.\n * @returns The default export.\n */\nexport function extractDefaultExportInterop<T>(module: ModuleWithDefaultExport<T> | T): T {\n  if (typeof module !== 'object' || module === null) {\n    return module;\n  }\n\n  if ('default' in module) {\n    return module.default;\n  }\n\n  return module;\n}\n\n/**\n * Gets all entries of an object.\n *\n * @param obj - The object to get the entries of.\n * @returns An array of all entries of the object.\n */\nexport function getAllEntries<T extends object>(obj: T): [StringKeys<T>, T[StringKeys<T>]][] {\n  return getAllKeys(obj).map((key) => [key, obj[key]]);\n}\n\n/**\n * Gets all keys of an object.\n * Includes fields and properties.\n *\n * @param obj - The object to get the keys of.\n * @returns An array of all keys of the object.\n */\nexport function getAllKeys<T extends object>(obj: T): StringKeys<T>[] {\n  const keys: StringKeys<T>[] = [];\n  let current: null | object = obj;\n  while (current) {\n    const descriptors = Object.getOwnPropertyDescriptors(current) as Record<string, PropertyDescriptor>;\n    for (const [key, descriptor] of Object.entries(descriptors)) {\n      if (key === '__proto__') {\n        continue;\n      }\n\n      if (typeof descriptor.value === 'function') {\n        continue;\n      }\n\n      const hasGetter = typeof descriptor.get === 'function';\n      const hasSetter = typeof descriptor.set === 'function';\n      if (hasGetter || hasSetter) {\n        if (hasGetter && hasSetter) {\n          keys.push(key as StringKeys<T>);\n        }\n        continue;\n      }\n\n      if (descriptor.enumerable && descriptor.writable) {\n        keys.push(key as StringKeys<T>);\n      }\n    }\n\n    current = Object.getPrototypeOf(current) as null | object;\n  }\n  return keys.sort();\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: GenericObject, path: string): unknown {\n  let node: GenericObject | undefined = obj;\n  const keys = path.split(KEY_SEPARATOR);\n  for (const key of keys) {\n    if (node === undefined) {\n      return undefined;\n    }\n    node = node[key] as GenericObject | 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 extends object>(name: StringKeys<T>): StringKeys<T> {\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 * Removes all `undefined` properties from an object when there are no mandatory keys with `undefined` values.\n *\n * @typeParam Type - The type of the object.\n * @param args - The arguments to the function.\n * @returns The object with all `undefined` properties removed.\n */\nexport function removeUndefinedProperties<Type extends object>(\n  ...args: RemoveUndefinedOverload<Type>\n): Type;\n/**\n * Removes all `undefined` properties from an object when there are mandatory keys with `undefined` values.\n *\n * @typeParam Type - The type of the object.\n * @typeParam KeysToKeep - The keys to keep.\n * @param args - The arguments to the function.\n * @returns The object with all `undefined` properties removed.\n */\nexport function removeUndefinedProperties<Type extends object, const KeysToKeep extends readonly string[]>(\n  ...args: RemoveUndefinedWithKeysOverload<Type, KeysToKeep>\n): Type;\n/**\n * Removes all `undefined` properties from an object.\n *\n * @typeParam Type - The type of the object.\n * @typeParam KeysToKeep - The keys to keep.\n * @param obj - The object to remove `undefined` properties from.\n * @param keysToKeep - The keys to keep.\n * @returns The object with all `undefined` properties removed.\n */\nexport function removeUndefinedProperties<Type extends object>(obj: Type, keysToKeep?: readonly string[]): Type {\n  for (const [key, value] of Object.entries(obj) as [StringKeys<Type>, unknown][]) {\n    if (value === undefined && !keysToKeep?.includes(key as string)) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n      delete obj[key];\n    }\n  }\n  return obj;\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: GenericObject, path: string, value: unknown): void {\n  const error = new Error(`Property path ${path} not found`);\n  let node: GenericObject | undefined = obj;\n  const keys = path.split(KEY_SEPARATOR);\n  for (const key of keys.slice(0, -1)) {\n    if (node === undefined) {\n      throw error;\n    }\n    node = node[key] as GenericObject | undefined;\n  }\n\n  const lastKey = ensureNonNullable(keys.at(-1));\n  if (node === 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 -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\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 = ensureNonNullable(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    const descriptors = Object.getOwnPropertyDescriptors(source);\n\n    for (const [key, descriptor] of Object.entries(descriptors)) {\n      try {\n        // Avoid redefining read-only properties (especially `prototype`)\n        if (\n          key === 'prototype'\n          || (Object.getOwnPropertyDescriptor(target, key)?.writable === false\n            && !Object.getOwnPropertyDescriptor(target, key)?.configurable)\n        ) {\n          continue;\n        }\n\n        Object.defineProperty(target, key, descriptor);\n      } catch {\n        // Silently ignore if defineProperty fails\n      }\n    }\n  }\n\n  const sourcePrototypes = sources\n    .map((source) => getPrototypeOf<object | undefined>(source))\n    .filter((proto): proto is object => !!proto);\n\n  if (sourcePrototypes.length > 0) {\n    const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);\n\n    try {\n      Object.setPrototypeOf(target, targetPrototype);\n    } catch {\n      // Silently ignore if setPrototypeOf fails\n    }\n  }\n\n  return target;\n}\n\nfunction applySubstitutions(params: ApplySubstitutionsParams): MaybeReturn<string> {\n  /* v8 ignore start -- All enum values are handled above; default branch is unreachable. */\n  switch (params.key) {\n    /* v8 ignore stop */\n    case TokenSubstitutionKey.CircularReference:\n      return params.substitutions.circularReference;\n    case TokenSubstitutionKey.Function:\n      return ensureNonNullable(params.functionTexts[params.index], `Function with index ${String(params.index)} not found`);\n    case TokenSubstitutionKey.MaxDepthLimitReached:\n      return params.substitutions.maxDepthLimitReached;\n    case TokenSubstitutionKey.MaxDepthLimitReachedArray:\n      return `Array(${String(params.index)})`;\n    case TokenSubstitutionKey.ToJSONFailed:\n      return params.substitutions.toJSONFailed;\n    case TokenSubstitutionKey.Undefined:\n      return 'undefined';\n    default:\n      /* v8 ignore start -- All enum values are handled above. */\n      break;\n      /* v8 ignore stop */\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- `unknown` doesn't work, getting compiler errors.\nfunction createEqualityComparerEntries<const T extends readonly EqualityComparerEntry<any>[]>(entries: T): T {\n  return entries;\n}\n\nfunction deepEqualArrayBuffer(a: ArrayBuffer, b: ArrayBuffer): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false;\n  }\n\n  const viewA = new Uint8Array(a);\n  const viewB = new Uint8Array(b);\n  return deepEqual(viewA, viewB);\n}\n\nfunction deepEqualDate(a: Date, b: Date): boolean {\n  return a.getTime() === b.getTime();\n}\n\nfunction deepEqualMap(a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a.entries()) {\n    if (!b.has(key) || !deepEqual(value, b.get(key))) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction deepEqualRegExp(a: RegExp, b: RegExp): boolean {\n  return a.source === b.source && a.flags === b.flags;\n}\n\nfunction deepEqualSet(a: Set<unknown>, b: Set<unknown>): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const valueA of a) {\n    if (b.has(valueA)) {\n      continue;\n    }\n    let found = false;\n    for (const valueB of b) {\n      if (deepEqual(valueA, valueB)) {\n        found = true;\n        break;\n      }\n    }\n    if (!found) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction deepEqualTyped(a: unknown, b: unknown): boolean | undefined {\n  for (const { constructor, equalityComparer } of equalityComparerEntries) {\n    if (a instanceof constructor && b instanceof constructor) {\n      return equalityComparer(a as never, b as never);\n    }\n  }\n  return undefined;\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, String(index), 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 -- We need to use `Function` type to handle them separately.\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    ? String(value)\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 ? String(index) : ''}]]`;\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/esm/obsidian/@types/i18next.d.mts

@@ -4,8 +4,8 @@
  * This file defines the `i18next` type options for the `obsidian` module.
  */
 
-import type { CustomTypeOptionsBase } from '../i18n/CustomTypeOptionsBase.mjs';
-import type { DefaultPluginTypes } from '../i18n/DefaultTranslationsBase.mjs';
+import type { CustomTypeOptionsBase } from '../i18n/custom-type-options-base.mjs';
+import type { DefaultPluginTypes } from '../i18n/default-translations-base.mjs';
 
 declare module 'i18next' {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- We need to use the empty object type, that's how `i18next` module works.

package/dist/lib/esm/obsidian/app.mjs

@@ -0,0 +1,62 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { noop } from "../function.mjs";
+class ValueWrapper {
+  /**
+   * Creates a new value wrapper.
+   *
+   * @param value - The value to wrap.
+   */
+  constructor(value) {
+    this.value = value;
+    noop();
+  }
+}
+function getApp() {
+  const app = globalThis.app;
+  if (app) {
+    return app;
+  }
+  try {
+    return globalThis.require('obsidian/app');
+  } catch {
+    throw new Error("Obsidian App global instance not found");
+  }
+}
+function getObsidianDevUtilsState(app, key, defaultValue) {
+  const holder = app ?? getAppOrNull() ?? globalThis;
+  const sharedStateWrapper = holder;
+  sharedStateWrapper.obsidianDevUtilsState ??= {};
+  return sharedStateWrapper.obsidianDevUtilsState[key] ??= new ValueWrapper(defaultValue);
+}
+function getAppOrNull() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return getApp();
+}
+export {
+  ValueWrapper,
+  getApp,
+  getObsidianDevUtilsState
+};
+//# sourceMappingURL=data:application/json;base64,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