obsidian-dev-utils 3.39.0 → 3.41.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 3.41.0
+
+- Handle broken canvas
+
+## 3.40.0
+
+- Add fix for unhandled `sourcemaps`
+- Add support for `FrontmatterLinkCache`
+
 ## 3.39.0
 
 - Avoid unnecessary renames

package/dist/lib/Object.cjs

@@ -26,8 +26,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Object_exports = {};
 __export(Object_exports, {
   deepEqual: () => deepEqual,
+  getNestedPropertyValue: () => getNestedPropertyValue,
   getPrototypeOf: () => getPrototypeOf,
   nameof: () => nameof,
+  setNestedPropertyValue: () => setNestedPropertyValue,
   toJson: () => toJson
 });
 module.exports = __toCommonJS(Object_exports);
@@ -85,11 +87,40 @@ function toJson(value, options = {}) {
   json = json.replaceAll(/"__FUNCTION_(\d+)"/g, (_, indexStr) => functionTexts[parseInt(indexStr)] ?? (0, import_Error.throwExpression)(new Error(`Function with index ${indexStr} not found`)));
   return json;
 }
+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 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   deepEqual,
+  getNestedPropertyValue,
   getPrototypeOf,
   nameof,
+  setNestedPropertyValue,
   toJson
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Object.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation Object\n * Contains utility functions for Objects.\n */\n\nimport { throwExpression } from './Error.ts';\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 * 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 * 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  return Object.getPrototypeOf(instance) as T;\n}\n\n/**\n * Options for converting an object to JSON.\n */\nexport interface ToJsonOptions {\n  /**\n   * If `true`, functions within the value will be handled and included in the JSON string. Defaults to `false`.\n   */\n  shouldHandleFunctions?: 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?: string | number | undefined;\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: ToJsonOptions = {}): string {\n  const {\n    shouldHandleFunctions = false,\n    space = 2\n  } = options;\n  if (!shouldHandleFunctions) {\n    return JSON.stringify(value, null, space);\n  }\n\n  const functionTexts: string[] = [];\n\n  const replacer = (_: string, value: unknown): unknown => {\n    if (typeof value === 'function') {\n      const index = functionTexts.length;\n      functionTexts.push(value.toString());\n      return `__FUNCTION_${index.toString()}`;\n    }\n\n    return value;\n  };\n\n  let json = JSON.stringify(value, replacer, space);\n  json = json.replaceAll(/\"__FUNCTION_(\\d+)\"/g, (_, indexStr: string) => functionTexts[parseInt(indexStr)] ?? throwExpression(new Error(`Function with index ${indexStr} not found`)));\n  return json;\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 * 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"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,mBAAgC;AAVhC,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAeO,SAAS,UAAU,GAAY,GAAqB;AACzD,MAAI,MAAM,GAAG;AACX,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,YAAY,MAAM,QAAQ,MAAM,MAAM;AAC9E,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,OAAO,KAAK,CAAC;AAC3B,QAAM,QAAQ,OAAO,KAAK,CAAC;AAE3B,MAAI,MAAM,WAAW,MAAM,QAAQ;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,UAAU;AAChB,QAAM,UAAU;AAEhB,aAAW,OAAO,OAAO;AACvB,QAAI,CAAC,MAAM,SAAS,GAAG,KAAK,CAAC,UAAU,QAAQ,GAAG,GAAG,QAAQ,GAAG,CAAC,GAAG;AAClE,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AASO,SAAS,OAAU,MAAwC;AAChE,SAAO;AACT;AASO,SAAS,eAAkB,UAAgB;AAChD,SAAO,OAAO,eAAe,QAAQ;AACvC;AAuBO,SAAS,OAAO,OAAgB,UAAyB,CAAC,GAAW;AAC1E,QAAM;AAAA,IACJ,wBAAwB;AAAA,IACxB,QAAQ;AAAA,EACV,IAAI;AACJ,MAAI,CAAC,uBAAuB;AAC1B,WAAO,KAAK,UAAU,OAAO,MAAM,KAAK;AAAA,EAC1C;AAEA,QAAM,gBAA0B,CAAC;AAEjC,QAAM,WAAW,CAAC,GAAWA,WAA4B;AACvD,QAAI,OAAOA,WAAU,YAAY;AAC/B,YAAM,QAAQ,cAAc;AAC5B,oBAAc,KAAKA,OAAM,SAAS,CAAC;AACnC,aAAO,cAAc,MAAM,SAAS,CAAC;AAAA,IACvC;AAEA,WAAOA;AAAA,EACT;AAEA,MAAI,OAAO,KAAK,UAAU,OAAO,UAAU,KAAK;AAChD,SAAO,KAAK,WAAW,uBAAuB,CAAC,GAAG,aAAqB,cAAc,SAAS,QAAQ,CAAC,SAAK,8BAAgB,IAAI,MAAM,uBAAuB,QAAQ,YAAY,CAAC,CAAC;AACnL,SAAO;AACT;AASO,SAAS,uBAAuB,KAA8B,MAAuB;AAC1F,MAAI,OAA4C;AAChD,QAAM,OAAO,KAAK,MAAM,GAAG;AAC3B,aAAW,OAAO,MAAM;AACtB,QAAI,SAAS,QAAW;AACtB,aAAO;AAAA,IACT;AACA,WAAO,KAAK,GAAG;AAAA,EACjB;AAEA,SAAO;AACT;AASO,SAAS,uBAAuB,KAA8B,MAAc,OAAsB;AACvG,QAAM,QAAQ,IAAI,MAAM,iBAAiB,IAAI,YAAY;AACzD,MAAI,OAA4C;AAChD,QAAM,OAAO,KAAK,MAAM,GAAG;AAC3B,aAAW,OAAO,KAAK,MAAM,GAAG,EAAE,GAAG;AACnC,QAAI,SAAS,QAAW;AACtB,YAAM;AAAA,IACR;AACA,WAAO,KAAK,GAAG;AAAA,EACjB;AAEA,QAAM,UAAU,KAAK,GAAG,EAAE;AAC1B,MAAI,SAAS,UAAa,YAAY,QAAW;AAC/C,UAAM;AAAA,EACR;AAEA,OAAK,OAAO,IAAI;AAClB;",
  "names": ["value"]
}


package/dist/lib/Object.d.ts

@@ -47,3 +47,19 @@ export interface ToJsonOptions {
  * @returns The JSON string representation of the input value.
  */
 export declare function toJson(value: unknown, options?: ToJsonOptions): string;
+/**
+ * Gets the value of a nested property from an object.
+ *
+ * @param obj - The object to get the nested property value from.
+ * @param path - The path to the nested property.
+ * @returns The value of the nested property.
+ */
+export declare function getNestedPropertyValue(obj: Record<string, unknown>, path: string): unknown;
+/**
+ * Sets the value of a nested property in an object.
+ *
+ * @param obj - The object to set the nested property value in.
+ * @param path - The path to the nested property.
+ * @param value - The value to set.
+ */
+export declare function setNestedPropertyValue(obj: Record<string, unknown>, path: string, value: unknown): void;

package/dist/lib/obsidian/FileChange.cjs

@@ -0,0 +1,142 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function patchRequireEsmDefault(){const __require=require;require=Object.assign(id=>{const module=__require(id);return module.__esModule&&module.default?module.default:module},__require)})()
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FileChange_exports = {};
+__export(FileChange_exports, {
+  applyFileChanges: () => applyFileChanges,
+  isContentChange: () => isContentChange,
+  isFrontmatterChange: () => isFrontmatterChange
+});
+module.exports = __toCommonJS(FileChange_exports);
+var import_Object = require('../Object.cjs');
+var import_ValueProvider = require('../ValueProvider.cjs');
+var import_FileSystem = require('./FileSystem.cjs');
+var import_FrontMatter = require('./FrontMatter.cjs');
+var import_Vault = require('./Vault.cjs');
+var __process = globalThis["process"] ?? {
+  "cwd": () => "/",
+  "env": {},
+  "platform": "android"
+};
+function isContentChange(fileChange) {
+  return fileChange.startIndex !== void 0;
+}
+function isFrontmatterChange(fileChange) {
+  return fileChange.frontMatterKey !== void 0;
+}
+async function applyFileChanges(app, pathOrFile, changesProvider, retryOptions = {}) {
+  const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
+  const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
+  await (0, import_Vault.process)(app, pathOrFile, async (content) => {
+    let changes = await (0, import_ValueProvider.resolveValue)(changesProvider);
+    const frontMatter = (0, import_FrontMatter.parseFrontMatter)(content);
+    for (const change of changes) {
+      if (isContentChange(change)) {
+        const actualContent = content.slice(change.startIndex, change.endIndex);
+        if (actualContent !== change.oldContent) {
+          console.warn("Content mismatch", {
+            startIndex: change.startIndex,
+            endIndex: change.endIndex,
+            path: (0, import_FileSystem.getPath)(pathOrFile),
+            expectedContent: change.oldContent,
+            actualContent
+          });
+          return null;
+        }
+      } else if (isFrontmatterChange(change)) {
+        const actualContent = (0, import_Object.getNestedPropertyValue)(frontMatter, change.frontMatterKey);
+        if (actualContent !== change.oldContent) {
+          console.warn("Content mismatch", {
+            path: (0, import_FileSystem.getPath)(pathOrFile),
+            expectedContent: change.oldContent,
+            actualContent,
+            frontMatterKey: change.frontMatterKey
+          });
+          return null;
+        }
+      }
+    }
+    changes.sort((a, b) => {
+      if (isContentChange(a) && isContentChange(b)) {
+        return a.startIndex - b.startIndex;
+      }
+      if (isFrontmatterChange(a) && isFrontmatterChange(b)) {
+        return a.frontMatterKey.localeCompare(b.frontMatterKey);
+      }
+      return isContentChange(a) ? -1 : 1;
+    });
+    changes = changes.filter((change, index) => {
+      if (change.oldContent === change.newContent) {
+        return false;
+      }
+      if (index === 0) {
+        return true;
+      }
+      return !(0, import_Object.deepEqual)(change, changes[index - 1]);
+    });
+    for (let i = 1; i < changes.length; i++) {
+      const change = changes[i];
+      if (!change) {
+        continue;
+      }
+      const previousChange = changes[i - 1];
+      if (!previousChange) {
+        continue;
+      }
+      if (isContentChange(previousChange) && isContentChange(change) && previousChange.endIndex && change.startIndex && previousChange.endIndex > change.startIndex) {
+        console.warn("Overlapping changes", {
+          previousChange,
+          change
+        });
+        return null;
+      }
+    }
+    let newContent = "";
+    let lastIndex = 0;
+    let frontMatterChanged = false;
+    for (const change of changes) {
+      if (isContentChange(change)) {
+        newContent += content.slice(lastIndex, change.startIndex);
+        newContent += change.newContent;
+        lastIndex = change.endIndex;
+      } else if (isFrontmatterChange(change)) {
+        (0, import_Object.setNestedPropertyValue)(frontMatter, change.frontMatterKey, change.newContent);
+        frontMatterChanged = true;
+      }
+    }
+    newContent += content.slice(lastIndex);
+    if (frontMatterChanged) {
+      newContent = (0, import_FrontMatter.setFrontMatter)(newContent, frontMatter);
+    }
+    return newContent;
+  }, overriddenOptions);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyFileChanges,
+  isContentChange,
+  isFrontmatterChange
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/FileChange.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type { App } from 'obsidian';\r\n\r\nimport type { RetryOptions } from '../Async.ts';\r\nimport {\r\n  deepEqual,\r\n  getNestedPropertyValue,\r\n  setNestedPropertyValue\r\n} from '../Object.ts';\r\nimport type { ValueProvider } from '../ValueProvider.ts';\r\nimport { resolveValue } from '../ValueProvider.ts';\r\nimport type { PathOrFile } from './FileSystem.ts';\r\nimport { getPath } from './FileSystem.ts';\r\nimport {\r\n  parseFrontMatter,\r\n  setFrontMatter\r\n} from './FrontMatter.ts';\r\nimport { process } from './Vault.ts';\r\n\r\n/**\r\n * Represents a file change in the Vault.\r\n */\r\nexport interface FileChange {\r\n  /**\r\n   * The old content that will be replaced.\r\n   */\r\n  oldContent: string;\r\n\r\n  /**\r\n   * The new content to replace the old content.\r\n   */\r\n  newContent: string;\r\n}\r\n\r\n/**\r\n * Represents a frontmatter change in the Vault.\r\n */\r\nexport interface FrontmatterChange extends FileChange {\r\n  /**\r\n   * The key in the frontmatter to use for the link.\r\n   */\r\n  frontMatterKey: string;\r\n}\r\n\r\n/**\r\n * Represents a content body change in the Vault.\r\n */\r\nexport interface ContentChange extends FileChange {\r\n  /**\r\n     * The start index of the change in the file content.\r\n     */\r\n  startIndex: number;\r\n\r\n  /**\r\n     * The end index of the change in the file content.\r\n     */\r\n  endIndex: number;\r\n}\r\n\r\n/**\r\n * Checks if a file change is a content change.\r\n *\r\n * @param fileChange - The file change to check.\r\n * @returns A boolean indicating whether the file change is a content change.\r\n */\r\nexport function isContentChange(fileChange: FileChange): fileChange is ContentChange {\r\n  return (fileChange as Partial<ContentChange>).startIndex !== undefined;\r\n}\r\n\r\n/**\r\n * Checks if a file change is a frontmatter change.\r\n *\r\n * @param fileChange - The file change to check.\r\n * @returns A boolean indicating whether the file change is a frontmatter change.\r\n */\r\nexport function isFrontmatterChange(fileChange: FileChange): fileChange is FrontmatterChange {\r\n  return (fileChange as Partial<FrontmatterChange>).frontMatterKey !== undefined;\r\n}\r\n\r\n/**\r\n * Applies a series of file changes to the specified file or path within the application.\r\n *\r\n * @param app - The application instance where the file changes will be applied.\r\n * @param pathOrFile - The path or file to which the changes should be applied.\r\n * @param changesProvider - A provider that returns an array of file changes to apply.\r\n * @param retryOptions - Optional settings that determine how the operation should retry on failure.\r\n *\r\n * @returns A promise that resolves when the file changes have been successfully applied.\r\n */\r\nexport async function applyFileChanges(app: App, pathOrFile: PathOrFile, changesProvider: ValueProvider<FileChange[]>, retryOptions: Partial<RetryOptions> = {}): Promise<void> {\r\n  const DEFAULT_RETRY_OPTIONS: Partial<RetryOptions> = { timeoutInMilliseconds: 60000 };\r\n  const overriddenOptions: Partial<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\r\n  await process(app, pathOrFile, async (content) => {\r\n    let changes = await resolveValue(changesProvider);\r\n    const frontMatter = parseFrontMatter(content);\r\n\r\n    for (const change of changes) {\r\n      if (isContentChange(change)) {\r\n        const actualContent = content.slice(change.startIndex, change.endIndex);\r\n        if (actualContent !== change.oldContent) {\r\n          console.warn('Content mismatch', {\r\n            startIndex: change.startIndex,\r\n            endIndex: change.endIndex,\r\n            path: getPath(pathOrFile),\r\n            expectedContent: change.oldContent,\r\n            actualContent\r\n          });\r\n\r\n          return null;\r\n        }\r\n      } else if (isFrontmatterChange(change)) {\r\n        const actualContent = getNestedPropertyValue(frontMatter, change.frontMatterKey);\r\n        if (actualContent !== change.oldContent) {\r\n          console.warn('Content mismatch', {\r\n            path: getPath(pathOrFile),\r\n            expectedContent: change.oldContent,\r\n            actualContent,\r\n            frontMatterKey: change.frontMatterKey\r\n          });\r\n\r\n          return null;\r\n        }\r\n      }\r\n    }\r\n\r\n    changes.sort((a, b) => {\r\n      if (isContentChange(a) && isContentChange(b)) {\r\n        return a.startIndex - b.startIndex;\r\n      }\r\n\r\n      if (isFrontmatterChange(a) && isFrontmatterChange(b)) {\r\n        return a.frontMatterKey.localeCompare(b.frontMatterKey);\r\n      }\r\n\r\n      return isContentChange(a) ? -1 : 1;\r\n    });\r\n\r\n    // BUG: https://forum.obsidian.md/t/bug-duplicated-links-in-metadatacache-inside-footnotes/85551\r\n    changes = changes.filter((change, index) => {\r\n      if (change.oldContent === change.newContent) {\r\n        return false;\r\n      }\r\n      if (index === 0) {\r\n        return true;\r\n      }\r\n      return !deepEqual(change, changes[index - 1]);\r\n    });\r\n\r\n    for (let i = 1; i < changes.length; i++) {\r\n      const change = changes[i];\r\n      if (!change) {\r\n        continue;\r\n      }\r\n      const previousChange = changes[i - 1];\r\n      if (!previousChange) {\r\n        continue;\r\n      }\r\n\r\n      if (isContentChange(previousChange) && isContentChange(change) && previousChange.endIndex && change.startIndex && previousChange.endIndex > change.startIndex) {\r\n        console.warn('Overlapping changes', {\r\n          previousChange,\r\n          change\r\n        });\r\n        return null;\r\n      }\r\n    }\r\n\r\n    let newContent = '';\r\n    let lastIndex = 0;\r\n    let frontMatterChanged = false;\r\n\r\n    for (const change of changes) {\r\n      if (isContentChange(change)) {\r\n        newContent += content.slice(lastIndex, change.startIndex);\r\n        newContent += change.newContent;\r\n        lastIndex = change.endIndex;\r\n      } else if (isFrontmatterChange(change)) {\r\n        setNestedPropertyValue(frontMatter, change.frontMatterKey, change.newContent);\r\n        frontMatterChanged = true;\r\n      }\r\n    }\r\n\r\n    newContent += content.slice(lastIndex);\r\n    if (frontMatterChanged) {\r\n      newContent = setFrontMatter(newContent, frontMatter);\r\n    }\r\n    return newContent;\r\n  }, overriddenOptions);\r\n}\r\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,oBAIO;AAEP,2BAA6B;AAE7B,wBAAwB;AACxB,yBAGO;AACP,mBAAwB;AArBxB,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAiEO,SAAS,gBAAgB,YAAqD;AACnF,SAAQ,WAAsC,eAAe;AAC/D;AAQO,SAAS,oBAAoB,YAAyD;AAC3F,SAAQ,WAA0C,mBAAmB;AACvE;AAYA,eAAsB,iBAAiB,KAAU,YAAwB,iBAA8C,eAAsC,CAAC,GAAkB;AAC9K,QAAM,wBAA+C,EAAE,uBAAuB,IAAM;AACpF,QAAM,oBAA2C,EAAE,GAAG,uBAAuB,GAAG,aAAa;AAC7F,YAAM,sBAAQ,KAAK,YAAY,OAAO,YAAY;AAChD,QAAI,UAAU,UAAM,mCAAa,eAAe;AAChD,UAAM,kBAAc,qCAAiB,OAAO;AAE5C,eAAW,UAAU,SAAS;AAC5B,UAAI,gBAAgB,MAAM,GAAG;AAC3B,cAAM,gBAAgB,QAAQ,MAAM,OAAO,YAAY,OAAO,QAAQ;AACtE,YAAI,kBAAkB,OAAO,YAAY;AACvC,kBAAQ,KAAK,oBAAoB;AAAA,YAC/B,YAAY,OAAO;AAAA,YACnB,UAAU,OAAO;AAAA,YACjB,UAAM,2BAAQ,UAAU;AAAA,YACxB,iBAAiB,OAAO;AAAA,YACxB;AAAA,UACF,CAAC;AAED,iBAAO;AAAA,QACT;AAAA,MACF,WAAW,oBAAoB,MAAM,GAAG;AACtC,cAAM,oBAAgB,sCAAuB,aAAa,OAAO,cAAc;AAC/E,YAAI,kBAAkB,OAAO,YAAY;AACvC,kBAAQ,KAAK,oBAAoB;AAAA,YAC/B,UAAM,2BAAQ,UAAU;AAAA,YACxB,iBAAiB,OAAO;AAAA,YACxB;AAAA,YACA,gBAAgB,OAAO;AAAA,UACzB,CAAC;AAED,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAEA,YAAQ,KAAK,CAAC,GAAG,MAAM;AACrB,UAAI,gBAAgB,CAAC,KAAK,gBAAgB,CAAC,GAAG;AAC5C,eAAO,EAAE,aAAa,EAAE;AAAA,MAC1B;AAEA,UAAI,oBAAoB,CAAC,KAAK,oBAAoB,CAAC,GAAG;AACpD,eAAO,EAAE,eAAe,cAAc,EAAE,cAAc;AAAA,MACxD;AAEA,aAAO,gBAAgB,CAAC,IAAI,KAAK;AAAA,IACnC,CAAC;AAGD,cAAU,QAAQ,OAAO,CAAC,QAAQ,UAAU;AAC1C,UAAI,OAAO,eAAe,OAAO,YAAY;AAC3C,eAAO;AAAA,MACT;AACA,UAAI,UAAU,GAAG;AACf,eAAO;AAAA,MACT;AACA,aAAO,KAAC,yBAAU,QAAQ,QAAQ,QAAQ,CAAC,CAAC;AAAA,IAC9C,CAAC;AAED,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,YAAM,SAAS,QAAQ,CAAC;AACxB,UAAI,CAAC,QAAQ;AACX;AAAA,MACF;AACA,YAAM,iBAAiB,QAAQ,IAAI,CAAC;AACpC,UAAI,CAAC,gBAAgB;AACnB;AAAA,MACF;AAEA,UAAI,gBAAgB,cAAc,KAAK,gBAAgB,MAAM,KAAK,eAAe,YAAY,OAAO,cAAc,eAAe,WAAW,OAAO,YAAY;AAC7J,gBAAQ,KAAK,uBAAuB;AAAA,UAClC;AAAA,UACA;AAAA,QACF,CAAC;AACD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,QAAI,aAAa;AACjB,QAAI,YAAY;AAChB,QAAI,qBAAqB;AAEzB,eAAW,UAAU,SAAS;AAC5B,UAAI,gBAAgB,MAAM,GAAG;AAC3B,sBAAc,QAAQ,MAAM,WAAW,OAAO,UAAU;AACxD,sBAAc,OAAO;AACrB,oBAAY,OAAO;AAAA,MACrB,WAAW,oBAAoB,MAAM,GAAG;AACtC,kDAAuB,aAAa,OAAO,gBAAgB,OAAO,UAAU;AAC5E,6BAAqB;AAAA,MACvB;AAAA,IACF;AAEA,kBAAc,QAAQ,MAAM,SAAS;AACrC,QAAI,oBAAoB;AACtB,uBAAa,mCAAe,YAAY,WAAW;AAAA,IACrD;AACA,WAAO;AAAA,EACT,GAAG,iBAAiB;AACtB;",
  "names": []
}


package/dist/lib/obsidian/FileChange.d.ts

@@ -0,0 +1,64 @@
+import type { App } from 'obsidian';
+import type { RetryOptions } from '../Async.ts';
+import type { ValueProvider } from '../ValueProvider.ts';
+import type { PathOrFile } from './FileSystem.ts';
+/**
+ * Represents a file change in the Vault.
+ */
+export interface FileChange {
+    /**
+     * The old content that will be replaced.
+     */
+    oldContent: string;
+    /**
+     * The new content to replace the old content.
+     */
+    newContent: string;
+}
+/**
+ * Represents a frontmatter change in the Vault.
+ */
+export interface FrontmatterChange extends FileChange {
+    /**
+     * The key in the frontmatter to use for the link.
+     */
+    frontMatterKey: string;
+}
+/**
+ * Represents a content body change in the Vault.
+ */
+export interface ContentChange extends FileChange {
+    /**
+       * The start index of the change in the file content.
+       */
+    startIndex: number;
+    /**
+       * The end index of the change in the file content.
+       */
+    endIndex: number;
+}
+/**
+ * Checks if a file change is a content change.
+ *
+ * @param fileChange - The file change to check.
+ * @returns A boolean indicating whether the file change is a content change.
+ */
+export declare function isContentChange(fileChange: FileChange): fileChange is ContentChange;
+/**
+ * Checks if a file change is a frontmatter change.
+ *
+ * @param fileChange - The file change to check.
+ * @returns A boolean indicating whether the file change is a frontmatter change.
+ */
+export declare function isFrontmatterChange(fileChange: FileChange): fileChange is FrontmatterChange;
+/**
+ * Applies a series of file changes to the specified file or path within the application.
+ *
+ * @param app - The application instance where the file changes will be applied.
+ * @param pathOrFile - The path or file to which the changes should be applied.
+ * @param changesProvider - A provider that returns an array of file changes to apply.
+ * @param retryOptions - Optional settings that determine how the operation should retry on failure.
+ *
+ * @returns A promise that resolves when the file changes have been successfully applied.
+ */
+export declare function applyFileChanges(app: App, pathOrFile: PathOrFile, changesProvider: ValueProvider<FileChange[]>, retryOptions?: Partial<RetryOptions>): Promise<void>;

package/dist/lib/obsidian/FileManager.cjs

@@ -0,0 +1,96 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function patchRequireEsmDefault(){const __require=require;require=Object.assign(id=>{const module=__require(id);return module.__esModule&&module.default?module.default:module},__require)})()
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FileManager_exports = {};
+__export(FileManager_exports, {
+  addAlias: () => addAlias,
+  deleteAlias: () => deleteAlias,
+  processFrontMatter: () => processFrontMatter
+});
+module.exports = __toCommonJS(FileManager_exports);
+var import_Object = require('../Object.cjs');
+var import_FileSystem = require('./FileSystem.cjs');
+var import_FrontMatter = require('./FrontMatter.cjs');
+var import_Vault = require('./Vault.cjs');
+var __process = globalThis["process"] ?? {
+  "cwd": () => "/",
+  "env": {},
+  "platform": "android"
+};
+async function processFrontMatter(app, pathOrFile, frontMatterFn, retryOptions = {}) {
+  const file = (0, import_FileSystem.getFile)(app, pathOrFile);
+  const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
+  const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
+  await (0, import_Vault.process)(app, file, async (content) => {
+    const oldFrontMatter = (0, import_FrontMatter.parseFrontMatter)(content);
+    const newFrontMatter = (0, import_FrontMatter.parseFrontMatter)(content);
+    const result = await frontMatterFn(newFrontMatter);
+    if (result === null) {
+      return null;
+    }
+    if ((0, import_Object.deepEqual)(oldFrontMatter, newFrontMatter)) {
+      return content;
+    }
+    return (0, import_FrontMatter.setFrontMatter)(content, newFrontMatter);
+  }, overriddenOptions);
+}
+async function addAlias(app, pathOrFile, alias) {
+  if (!alias) {
+    return;
+  }
+  const file = (0, import_FileSystem.getFile)(app, pathOrFile);
+  if (alias === file.basename) {
+    return;
+  }
+  await processFrontMatter(app, pathOrFile, (frontMatter) => {
+    if (!frontMatter.aliases) {
+      frontMatter.aliases = [];
+    }
+    if (!frontMatter.aliases.includes(alias)) {
+      frontMatter.aliases.push(alias);
+    }
+  });
+}
+async function deleteAlias(app, pathOrFile, alias) {
+  if (!alias) {
+    return;
+  }
+  await processFrontMatter(app, pathOrFile, (frontMatter) => {
+    if (!frontMatter.aliases) {
+      return;
+    }
+    frontMatter.aliases = frontMatter.aliases.filter((a) => a != alias);
+    if (frontMatter.aliases.length === 0) {
+      delete frontMatter.aliases;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAlias,
+  deleteAlias,
+  processFrontMatter
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/obsidian/FileManager.d.ts

@@ -0,0 +1,33 @@
+import type { App } from 'obsidian';
+import type { MaybePromise, RetryOptions } from '../Async.ts';
+import type { PathOrFile } from './FileSystem.ts';
+import type { CombinedFrontMatter } from './FrontMatter.ts';
+/**
+ * Processes the front matter of a given file, allowing modifications via a provided function.
+ *
+ * @typeParam CustomFrontMatter - The type of custom front matter.
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or TFile object representing the note.
+ * @param frontMatterFn - A function that modifies the front matter.
+ * @param retryOptions - Optional. Configuration options for retrying the process. If not provided, default options will be used.
+ * @returns A promise that resolves when the front matter has been processed and saved.
+ */
+export declare function processFrontMatter<CustomFrontMatter = unknown>(app: App, pathOrFile: PathOrFile, frontMatterFn: (frontMatter: CombinedFrontMatter<CustomFrontMatter>) => MaybePromise<void | null>, retryOptions?: Partial<RetryOptions>): Promise<void>;
+/**
+ * Adds an alias to the front matter of a given file if it does not already exist.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or TFile object representing the note.
+ * @param alias - The alias to add.
+ * @returns A promise that resolves when the alias has been added.
+ */
+export declare function addAlias(app: App, pathOrFile: PathOrFile, alias?: string): Promise<void>;
+/**
+ * Deletes an alias from the front matter of a given file if it exists.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or TFile object representing the note.
+ * @param alias - The alias to delete.
+ * @returns A promise that resolves when the alias has been deleted.
+ */
+export declare function deleteAlias(app: App, pathOrFile: PathOrFile, alias?: string): Promise<void>;

package/dist/lib/obsidian/FrontMatter.cjs

@@ -25,77 +25,31 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var FrontMatter_exports = {};
 __export(FrontMatter_exports, {
-  addAlias: () => addAlias,
-  deleteAlias: () => deleteAlias,
-  processFrontMatter: () => processFrontMatter
+  parseFrontMatter: () => parseFrontMatter,
+  setFrontMatter: () => setFrontMatter
 });
 module.exports = __toCommonJS(FrontMatter_exports);
 var import_obsidian = require('obsidian');
-var import_Object = require('../Object.cjs');
-var import_FileSystem = require('./FileSystem.cjs');
-var import_Vault = require('./Vault.cjs');
 var __process = globalThis["process"] ?? {
   "cwd": () => "/",
   "env": {},
   "platform": "android"
 };
-async function processFrontMatter(app, pathOrFile, frontMatterFn, retryOptions = {}) {
-  const file = (0, import_FileSystem.getFile)(app, pathOrFile);
-  const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
-  const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
-  await (0, import_Vault.process)(app, file, async (content) => {
-    const frontMatterInfo = (0, import_obsidian.getFrontMatterInfo)(content);
-    const oldFrontMatter = (0, import_obsidian.parseYaml)(frontMatterInfo.frontmatter) ?? {};
-    const newFrontMatter = (0, import_obsidian.parseYaml)(frontMatterInfo.frontmatter) ?? {};
-    const result = await frontMatterFn(newFrontMatter);
-    if (result === null) {
-      return null;
-    }
-    if ((0, import_Object.deepEqual)(oldFrontMatter, newFrontMatter)) {
-      return content;
-    }
-    if (Object.keys(newFrontMatter).length === 0) {
-      return content.slice(frontMatterInfo.contentStart);
-    }
-    const newFrontMatterStr = (0, import_obsidian.stringifyYaml)(newFrontMatter);
-    return frontMatterInfo.exists ? content.slice(0, frontMatterInfo.from) + newFrontMatterStr + content.slice(frontMatterInfo.to) : "---\n" + newFrontMatterStr + "---\n" + content;
-  }, overriddenOptions);
+function parseFrontMatter(content) {
+  const frontMatterInfo = (0, import_obsidian.getFrontMatterInfo)(content);
+  return (0, import_obsidian.parseYaml)(frontMatterInfo.frontmatter) ?? {};
 }
-async function addAlias(app, pathOrFile, alias) {
-  if (!alias) {
-    return;
+function setFrontMatter(content, newFrontMatter) {
+  const frontMatterInfo = (0, import_obsidian.getFrontMatterInfo)(content);
+  if (Object.keys(newFrontMatter).length === 0) {
+    return content.slice(frontMatterInfo.contentStart);
   }
-  const file = (0, import_FileSystem.getFile)(app, pathOrFile);
-  if (alias === file.basename) {
-    return;
-  }
-  await processFrontMatter(app, pathOrFile, (frontMatter) => {
-    if (!frontMatter.aliases) {
-      frontMatter.aliases = [];
-    }
-    if (!frontMatter.aliases.includes(alias)) {
-      frontMatter.aliases.push(alias);
-    }
-  });
-}
-async function deleteAlias(app, pathOrFile, alias) {
-  if (!alias) {
-    return;
-  }
-  await processFrontMatter(app, pathOrFile, (frontMatter) => {
-    if (!frontMatter.aliases) {
-      return;
-    }
-    frontMatter.aliases = frontMatter.aliases.filter((a) => a != alias);
-    if (frontMatter.aliases.length === 0) {
-      delete frontMatter.aliases;
-    }
-  });
+  const newFrontMatterStr = (0, import_obsidian.stringifyYaml)(newFrontMatter);
+  return frontMatterInfo.exists ? content.slice(0, frontMatterInfo.from) + newFrontMatterStr + content.slice(frontMatterInfo.to) : "---\n" + newFrontMatterStr + "---\n" + content;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  addAlias,
-  deleteAlias,
-  processFrontMatter
+  parseFrontMatter,
+  setFrontMatter
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/FrontMatter.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation FrontMatter\n * This module provides utility functions for processing and managing YAML front matter in Obsidian notes.\n */\n\nimport {\n  App,\n  getFrontMatterInfo,\n  parseYaml,\n  stringifyYaml\n} from 'obsidian';\n\nimport type {\n  MaybePromise,\n  RetryOptions\n} from '../Async.ts';\nimport { deepEqual } from '../Object.ts';\nimport type { PathOrFile } from './FileSystem.ts';\nimport { getFile } from './FileSystem.ts';\nimport { process } from './Vault.ts';\n\n/**\n * Represents the front matter of an Obsidian file.\n * @see {@link https://help.obsidian.md/Editing+and+formatting/Properties#Default+properties}\n */\nexport interface ObsidianFrontMatter {\n  /**\n   * An array of aliases for the note.\n   */\n  aliases?: string[];\n\n  /**\n   * An array of CSS classes to apply to the note.\n   */\n  cssclasses?: string[];\n\n  /**\n   * An array of tags for the note.\n   */\n  tags?: string[];\n}\n\n/**\n * Represents the front matter for publishing in Obsidian.\n * @see {@link https://help.obsidian.md/Editing+and+formatting/Properties#Properties+for+Obsidian+Publish}\n */\nexport interface ObsidianPublishFrontMatter {\n  /**\n   * The cover image for the note.\n   */\n  cover?: string;\n\n  /**\n   * The description for the note.\n   */\n  description?: string;\n\n  /**\n   * The image for the note.\n   */\n  image?: string;\n\n  /**\n   * The permanent link for the note.\n   */\n  permalink?: string;\n\n  /**\n   * Whether the note is published.\n   */\n  publish?: boolean;\n}\n\n/**\n * Represents the combined front matter of a document.\n * It is a union of custom front matter, Obsidian front matter, and additional properties.\n * @typeParam CustomFrontMatter - The type of custom front matter.\n */\nexport type CombinedFrontMatter<CustomFrontMatter> = CustomFrontMatter & ObsidianFrontMatter & Record<string, unknown>;\n\n/**\n * Processes the front matter of a given file, allowing modifications via a provided function.\n *\n * @typeParam CustomFrontMatter - The type of custom front matter.\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or TFile object representing the note.\n * @param frontMatterFn - A function that modifies the front matter.\n * @param retryOptions - Optional. Configuration options for retrying the process. If not provided, default options will be used.\n * @returns A promise that resolves when the front matter has been processed and saved.\n */\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type\nexport async function processFrontMatter<CustomFrontMatter = unknown>(app: App, pathOrFile: PathOrFile, frontMatterFn: (frontMatter: CombinedFrontMatter<CustomFrontMatter>) => MaybePromise<void | null>, retryOptions: Partial<RetryOptions> = {}): Promise<void> {\n  const file = getFile(app, pathOrFile);\n  const DEFAULT_RETRY_OPTIONS: Partial<RetryOptions> = { timeoutInMilliseconds: 60000 };\n  const overriddenOptions: Partial<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n\n  await process(app, file, async (content) => {\n    const frontMatterInfo = getFrontMatterInfo(content);\n\n    const oldFrontMatter = (parseYaml(frontMatterInfo.frontmatter) ?? {}) as CombinedFrontMatter<CustomFrontMatter>;\n    const newFrontMatter = (parseYaml(frontMatterInfo.frontmatter) ?? {}) as CombinedFrontMatter<CustomFrontMatter>;\n    const result = await frontMatterFn(newFrontMatter);\n    if (result === null) {\n      return null;\n    }\n\n    if (deepEqual(oldFrontMatter, newFrontMatter)) {\n      return content;\n    }\n\n    if (Object.keys(newFrontMatter).length === 0) {\n      return content.slice(frontMatterInfo.contentStart);\n    }\n\n    const newFrontMatterStr = stringifyYaml(newFrontMatter);\n\n    return frontMatterInfo.exists\n      ? content.slice(0, frontMatterInfo.from) + newFrontMatterStr + content.slice(frontMatterInfo.to)\n      : '---\\n' + newFrontMatterStr + '---\\n' + content;\n  }, overriddenOptions);\n}\n\n/**\n * Adds an alias to the front matter of a given file if it does not already exist.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or TFile object representing the note.\n * @param alias - The alias to add.\n * @returns A promise that resolves when the alias has been added.\n */\nexport async function addAlias(app: App, pathOrFile: PathOrFile, alias?: string): Promise<void> {\n  if (!alias) {\n    return;\n  }\n\n  const file = getFile(app, pathOrFile);\n  if (alias === file.basename) {\n    return;\n  }\n\n  await processFrontMatter(app, pathOrFile, (frontMatter) => {\n    if (!frontMatter.aliases) {\n      frontMatter.aliases = [];\n    }\n\n    if (!frontMatter.aliases.includes(alias)) {\n      frontMatter.aliases.push(alias);\n    }\n  });\n}\n\n/**\n * Deletes an alias from the front matter of a given file if it exists.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or TFile object representing the note.\n * @param alias - The alias to delete.\n * @returns A promise that resolves when the alias has been deleted.\n */\nexport async function deleteAlias(app: App, pathOrFile: PathOrFile, alias?: string): Promise<void> {\n  if (!alias) {\n    return;\n  }\n\n  await processFrontMatter(app, pathOrFile, (frontMatter) => {\n    if (!frontMatter.aliases) {\n      return;\n    }\n\n    frontMatter.aliases = frontMatter.aliases.filter((a) => a != alias);\n\n    if (frontMatter.aliases.length === 0) {\n      delete frontMatter.aliases;\n    }\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,sBAKO;AAMP,oBAA0B;AAE1B,wBAAwB;AACxB,mBAAwB;AAxBxB,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AA4FA,eAAsB,mBAAgD,KAAU,YAAwB,eAAmG,eAAsC,CAAC,GAAkB;AAClQ,QAAM,WAAO,2BAAQ,KAAK,UAAU;AACpC,QAAM,wBAA+C,EAAE,uBAAuB,IAAM;AACpF,QAAM,oBAA2C,EAAE,GAAG,uBAAuB,GAAG,aAAa;AAE7F,YAAM,sBAAQ,KAAK,MAAM,OAAO,YAAY;AAC1C,UAAM,sBAAkB,oCAAmB,OAAO;AAElD,UAAM,qBAAkB,2BAAU,gBAAgB,WAAW,KAAK,CAAC;AACnE,UAAM,qBAAkB,2BAAU,gBAAgB,WAAW,KAAK,CAAC;AACnE,UAAM,SAAS,MAAM,cAAc,cAAc;AACjD,QAAI,WAAW,MAAM;AACnB,aAAO;AAAA,IACT;AAEA,YAAI,yBAAU,gBAAgB,cAAc,GAAG;AAC7C,aAAO;AAAA,IACT;AAEA,QAAI,OAAO,KAAK,cAAc,EAAE,WAAW,GAAG;AAC5C,aAAO,QAAQ,MAAM,gBAAgB,YAAY;AAAA,IACnD;AAEA,UAAM,wBAAoB,+BAAc,cAAc;AAEtD,WAAO,gBAAgB,SACnB,QAAQ,MAAM,GAAG,gBAAgB,IAAI,IAAI,oBAAoB,QAAQ,MAAM,gBAAgB,EAAE,IAC7F,UAAU,oBAAoB,UAAU;AAAA,EAC9C,GAAG,iBAAiB;AACtB;AAUA,eAAsB,SAAS,KAAU,YAAwB,OAA+B;AAC9F,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,QAAM,WAAO,2BAAQ,KAAK,UAAU;AACpC,MAAI,UAAU,KAAK,UAAU;AAC3B;AAAA,EACF;AAEA,QAAM,mBAAmB,KAAK,YAAY,CAAC,gBAAgB;AACzD,QAAI,CAAC,YAAY,SAAS;AACxB,kBAAY,UAAU,CAAC;AAAA,IACzB;AAEA,QAAI,CAAC,YAAY,QAAQ,SAAS,KAAK,GAAG;AACxC,kBAAY,QAAQ,KAAK,KAAK;AAAA,IAChC;AAAA,EACF,CAAC;AACH;AAUA,eAAsB,YAAY,KAAU,YAAwB,OAA+B;AACjG,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,QAAM,mBAAmB,KAAK,YAAY,CAAC,gBAAgB;AACzD,QAAI,CAAC,YAAY,SAAS;AACxB;AAAA,IACF;AAEA,gBAAY,UAAU,YAAY,QAAQ,OAAO,CAAC,MAAM,KAAK,KAAK;AAElE,QAAI,YAAY,QAAQ,WAAW,GAAG;AACpC,aAAO,YAAY;AAAA,IACrB;AAAA,EACF,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,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