@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/file-explorer.mjs

@@ -0,0 +1,68 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { requestAnimationFrameAsync } from "@mnaoumov/typescript-lib/async";
+import { InternalPluginName } from "@obsidian-typings/obsidian-public-latest/implementations";
+const FRAMES_TO_OUTLAST_THE_EXPLORER_ACTIVATION = 2;
+async function revealInFileExplorer(params) {
+  const { abstractFile, app } = params;
+  const fileExplorer = app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer);
+  if (!fileExplorer) {
+    return;
+  }
+  const revealInFolder = fileExplorer.revealInFolder.bind(fileExplorer);
+  await revealInFolder(abstractFile);
+  for (let frame = 0; frame < FRAMES_TO_OUTLAST_THE_EXPLORER_ACTIVATION; frame++) {
+    await requestAnimationFrameAsync();
+  }
+}
+export {
+  revealInFileExplorer
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/file-manager.d.mts

@@ -0,0 +1,123 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for managing files in Obsidian.
+ */
+import type { MaybeReturn } from '@mnaoumov/typescript-lib/type';
+import type { App } from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { PathOrFile } from './file-system.mjs';
+import type { CombinedFrontmatter } from './frontmatter.mjs';
+import type { ResourceLockComponent } from './resource-lock.mjs';
+import type { ProcessOptions } from './vault.mjs';
+/**
+ * Parameters for {@link addAlias}.
+ */
+export interface AddAliasParams {
+    /**
+     * The alias to add.
+     */
+    readonly alias?: string;
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The path or TFile object representing the note.
+     */
+    readonly pathOrFile: PathOrFile;
+    /**
+     * The resource-lock component used to lock the note while it is being modified.
+     */
+    readonly resourceLockComponent: null | ResourceLockComponent;
+}
+/**
+ * Parameters for {@link deleteAlias}.
+ */
+export interface DeleteAliasParams {
+    /**
+     * The alias to delete.
+     */
+    readonly alias?: string;
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The path or TFile object representing the note.
+     */
+    readonly pathOrFile: PathOrFile;
+    /**
+     * The resource-lock component used to lock the note while it is being modified.
+     */
+    readonly resourceLockComponent: null | ResourceLockComponent;
+}
+/**
+ * Options for {@link processFrontmatter}.
+ */
+export type ProcessFrontmatterOptions = ProcessOptions;
+/**
+ * Parameters for {@link processFrontmatter}.
+ *
+ * @typeParam CustomFrontmatter - The type of custom front matter.
+ */
+export interface ProcessFrontmatterParams<CustomFrontmatter = unknown> extends ProcessFrontmatterOptions {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * A function that modifies the front matter.
+     *
+     * @param frontmatter - The front matter to modify.
+     * @param abortSignal - The abort signal to listen to.
+     * @returns A value that may be `null` to abort the process.
+     */
+    readonly frontmatterFunction: (frontmatter: CombinedFrontmatter<CustomFrontmatter>, abortSignal: AbortSignal) => Promisable<MaybeReturn<null>>;
+    /**
+     * The path or TFile object representing the note.
+     */
+    readonly pathOrFile: PathOrFile;
+}
+/**
+ * Adds an alias to the front matter of a given file if it does not already exist.
+ *
+ * @param params - The parameters for adding the alias.
+ * @returns A {@link Promise} that resolves when the alias has been added.
+ */
+export declare function addAlias(params: AddAliasParams): Promise<void>;
+/**
+ * Deletes an alias from the front matter of a given file if it exists.
+ *
+ * @param params - The parameters for deleting the alias.
+ * @returns A {@link Promise} that resolves when the alias has been deleted.
+ */
+export declare function deleteAlias(params: DeleteAliasParams): Promise<void>;
+/**
+ * Processes the front matter of a given file, allowing modifications via a provided function.
+ *
+ * @typeParam CustomFrontmatter - The type of custom front matter.
+ * @param params - The parameters for processing the front matter.
+ * @returns A {@link Promise} that resolves when the front matter has been processed and saved.
+ */
+export declare function processFrontmatter<CustomFrontmatter = unknown>(params: ProcessFrontmatterParams<CustomFrontmatter>): Promise<void>;
+/**
+ * Waits until Obsidian's own in-flight link update has decided which links to rewrite.
+ *
+ * `FileManager.runAsyncLinkUpdate()` snapshots every reference's resolved paths, sets
+ * `FileManager.inProgressUpdates` to an array, and invokes the passed handler — the handler being what
+ * performs the actual rename. In its `finally` block it sets `inProgressUpdates` back to `null` and
+ * then immediately calls `FileManager.updateAllLinks()`, whose per-reference decision — rewrite only
+ * when the link's resolved paths changed — runs synchronously, with no `await` in between. So
+ * observing a `null` `inProgressUpdates` proves that decision has already been made.
+ *
+ * That matters for any code that temporarily registers a phantom file at a path that no longer exists
+ * (see `registerFiles` in `metadata-cache.ts`) and holds that registration across an `await`: while it
+ * is live, a link to the old path still resolves, so Obsidian concludes nothing changed and silently
+ * rewrites nothing. Awaiting this function before registering keeps the phantom out of that decision.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns A {@link Promise} that resolves once no link update is in flight.
+ */
+export declare function waitForPendingLinkUpdates(app: App): Promise<void>;

package/dist/lib/esm/file-manager.mjs

@@ -0,0 +1,169 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { retryWithTimeout } from "@mnaoumov/typescript-lib/async";
+import {
+  isDeepEqual,
+  normalizeOptionalProperties
+} from "@mnaoumov/typescript-lib/object-utils";
+import {
+  getFile,
+  getPath,
+  isMarkdownFile
+} from "./file-system.mjs";
+import {
+  parseFrontmatter,
+  setFrontmatter
+} from "./frontmatter.mjs";
+import { process } from "./vault.mjs";
+async function addAlias(params) {
+  const {
+    alias,
+    app,
+    pathOrFile,
+    resourceLockComponent
+  } = params;
+  if (!alias) {
+    return;
+  }
+  const file = getFile({ app, pathOrFile });
+  if (!isMarkdownFile(file)) {
+    throw new Error(`File ${file.path} is not a markdown file.`);
+  }
+  if (alias === file.basename || alias === file.name) {
+    return;
+  }
+  await processFrontmatter({
+    app,
+    frontmatterFunction: (frontmatter) => {
+      frontmatter.aliases ??= [];
+      if (!frontmatter.aliases.includes(alias)) {
+        frontmatter.aliases.push(alias);
+      }
+    },
+    pathOrFile,
+    pluginNoticeComponent: null,
+    resourceLockComponent
+  });
+}
+async function deleteAlias(params) {
+  const {
+    alias,
+    app,
+    pathOrFile,
+    resourceLockComponent
+  } = params;
+  if (!alias) {
+    return;
+  }
+  if (!isMarkdownFile(pathOrFile)) {
+    throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);
+  }
+  await processFrontmatter({
+    app,
+    frontmatterFunction: (frontmatter) => {
+      if (!frontmatter.aliases) {
+        return;
+      }
+      frontmatter.aliases = frontmatter.aliases.filter((a) => a !== alias);
+      if (frontmatter.aliases.length === 0) {
+        delete frontmatter.aliases;
+      }
+    },
+    pathOrFile,
+    pluginNoticeComponent: null,
+    resourceLockComponent
+  });
+}
+async function processFrontmatter(params) {
+  const {
+    app,
+    frontmatterFunction,
+    pathOrFile,
+    ...options
+  } = params;
+  if (!isMarkdownFile(pathOrFile)) {
+    throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);
+  }
+  await process(normalizeOptionalProperties({
+    app,
+    async newContentProvider({ abortSignal, content }) {
+      abortSignal.throwIfAborted();
+      const oldFrontmatter = parseFrontmatter(content);
+      const newFrontmatter = parseFrontmatter(content);
+      const result = await frontmatterFunction(newFrontmatter, abortSignal);
+      abortSignal.throwIfAborted();
+      if (result === null) {
+        return null;
+      }
+      return isDeepEqual(oldFrontmatter, newFrontmatter) ? content : setFrontmatter(content, newFrontmatter);
+    },
+    pathOrFile,
+    ...options
+  }));
+}
+async function waitForPendingLinkUpdates(app) {
+  const TIMEOUT_IN_MILLISECONDS = 6e4;
+  await retryWithTimeout({
+    operationFunction: () => app.fileManager.inProgressUpdates === null,
+    operationName: "waitForPendingLinkUpdates",
+    retryOptions: {
+      // Poll on the macrotask queue: the link update settles through microtasks, so any positive delay only adds latency.
+      retryDelayInMilliseconds: 0,
+      timeoutInMilliseconds: TIMEOUT_IN_MILLISECONDS
+    }
+  });
+}
+export {
+  addAlias,
+  deleteAlias,
+  processFrontmatter,
+  waitForPendingLinkUpdates
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/file-manager.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for managing files in Obsidian.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { retryWithTimeout } from '@mnaoumov/typescript-lib/async';\nimport {\n  isDeepEqual,\n  normalizeOptionalProperties\n} from '@mnaoumov/typescript-lib/object-utils';\n\nimport type { PathOrFile } from './file-system.ts';\nimport type { CombinedFrontmatter } from './frontmatter.ts';\nimport type { ResourceLockComponent } from './resource-lock.ts';\nimport type {\n  ProcessOptions,\n  ProcessParams\n} from './vault.ts';\n\nimport {\n  getFile,\n  getPath,\n  isMarkdownFile\n} from './file-system.ts';\nimport {\n  parseFrontmatter,\n  setFrontmatter\n} from './frontmatter.ts';\nimport { process } from './vault.ts';\n\n/**\n * Parameters for {@link addAlias}.\n */\nexport interface AddAliasParams {\n  /**\n   * The alias to add.\n   */\n  readonly alias?: string;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or TFile object representing the note.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n}\n\n/**\n * Parameters for {@link deleteAlias}.\n */\nexport interface DeleteAliasParams {\n  /**\n   * The alias to delete.\n   */\n  readonly alias?: string;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or TFile object representing the note.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n}\n\n/**\n * Options for {@link processFrontmatter}.\n */\nexport type ProcessFrontmatterOptions = ProcessOptions;\n\n/**\n * Parameters for {@link processFrontmatter}.\n *\n * @typeParam CustomFrontmatter - The type of custom front matter.\n */\nexport interface ProcessFrontmatterParams<CustomFrontmatter = unknown> extends ProcessFrontmatterOptions {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * A function that modifies the front matter.\n   *\n   * @param frontmatter - The front matter to modify.\n   * @param abortSignal - The abort signal to listen to.\n   * @returns A value that may be `null` to abort the process.\n   */\n  readonly frontmatterFunction: (frontmatter: CombinedFrontmatter<CustomFrontmatter>, abortSignal: AbortSignal) => Promisable<MaybeReturn<null>>;\n\n  /**\n   * The path or TFile object representing the note.\n   */\n  readonly pathOrFile: PathOrFile;\n}\n\n/**\n * Adds an alias to the front matter of a given file if it does not already exist.\n *\n * @param params - The parameters for adding the alias.\n * @returns A {@link Promise} that resolves when the alias has been added.\n */\nexport async function addAlias(params: AddAliasParams): Promise<void> {\n  const {\n    alias,\n    app,\n    pathOrFile,\n    resourceLockComponent\n  } = params;\n  if (!alias) {\n    return;\n  }\n\n  const file = getFile({ app, pathOrFile });\n\n  if (!isMarkdownFile(file)) {\n    throw new Error(`File ${file.path} is not a markdown file.`);\n  }\n\n  if (alias === file.basename || alias === file.name) {\n    return;\n  }\n\n  await processFrontmatter({\n    app,\n    frontmatterFunction: (frontmatter) => {\n      frontmatter.aliases ??= [];\n\n      if (!frontmatter.aliases.includes(alias)) {\n        frontmatter.aliases.push(alias);\n      }\n    },\n    pathOrFile,\n    pluginNoticeComponent: null,\n    resourceLockComponent\n  });\n}\n\n/**\n * Deletes an alias from the front matter of a given file if it exists.\n *\n * @param params - The parameters for deleting the alias.\n * @returns A {@link Promise} that resolves when the alias has been deleted.\n */\nexport async function deleteAlias(params: DeleteAliasParams): Promise<void> {\n  const {\n    alias,\n    app,\n    pathOrFile,\n    resourceLockComponent\n  } = params;\n  if (!alias) {\n    return;\n  }\n\n  if (!isMarkdownFile(pathOrFile)) {\n    throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);\n  }\n\n  await processFrontmatter({\n    app,\n    frontmatterFunction: (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    pathOrFile,\n    pluginNoticeComponent: null,\n    resourceLockComponent\n  });\n}\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 params - The parameters for processing the front matter.\n * @returns A {@link Promise} that resolves when the front matter has been processed and saved.\n */\nexport async function processFrontmatter<CustomFrontmatter = unknown>(params: ProcessFrontmatterParams<CustomFrontmatter>): Promise<void> {\n  const {\n    app,\n    frontmatterFunction,\n    pathOrFile,\n    ...options\n  } = params;\n  if (!isMarkdownFile(pathOrFile)) {\n    throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);\n  }\n\n  await process(normalizeOptionalProperties<ProcessParams>({\n    app,\n    async newContentProvider({ abortSignal, content }) {\n      abortSignal.throwIfAborted();\n\n      const oldFrontmatter = parseFrontmatter<CustomFrontmatter>(content);\n      const newFrontmatter = parseFrontmatter<CustomFrontmatter>(content);\n      const result = await frontmatterFunction(newFrontmatter, abortSignal);\n      abortSignal.throwIfAborted();\n\n      if (result === null) {\n        return null;\n      }\n\n      return isDeepEqual(oldFrontmatter, newFrontmatter) ? content : setFrontmatter(content, newFrontmatter);\n    },\n    pathOrFile,\n    ...options\n  }));\n}\n\n/**\n * Waits until Obsidian's own in-flight link update has decided which links to rewrite.\n *\n * `FileManager.runAsyncLinkUpdate()` snapshots every reference's resolved paths, sets\n * `FileManager.inProgressUpdates` to an array, and invokes the passed handler \u2014 the handler being what\n * performs the actual rename. In its `finally` block it sets `inProgressUpdates` back to `null` and\n * then immediately calls `FileManager.updateAllLinks()`, whose per-reference decision \u2014 rewrite only\n * when the link's resolved paths changed \u2014 runs synchronously, with no `await` in between. So\n * observing a `null` `inProgressUpdates` proves that decision has already been made.\n *\n * That matters for any code that temporarily registers a phantom file at a path that no longer exists\n * (see `registerFiles` in `metadata-cache.ts`) and holds that registration across an `await`: while it\n * is live, a link to the old path still resolves, so Obsidian concludes nothing changed and silently\n * rewrites nothing. Awaiting this function before registering keeps the phantom out of that decision.\n *\n * @param app - The Obsidian app instance.\n * @returns A {@link Promise} that resolves once no link update is in flight.\n */\nexport async function waitForPendingLinkUpdates(app: App): Promise<void> {\n  const TIMEOUT_IN_MILLISECONDS = 60_000;\n  await retryWithTimeout({\n    operationFunction: () => app.fileManager.inProgressUpdates === null,\n    operationName: 'waitForPendingLinkUpdates',\n    retryOptions: {\n      // Poll on the macrotask queue: the link update settles through microtasks, so any positive delay only adds latency.\n      retryDelayInMilliseconds: 0,\n      timeoutInMilliseconds: TIMEOUT_IN_MILLISECONDS\n    }\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAUP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,eAAe;AAyFxB,eAAsB,SAAS,QAAuC;AACpE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,QAAM,OAAO,QAAQ,EAAE,KAAK,WAAW,CAAC;AAExC,MAAI,CAAC,eAAe,IAAI,GAAG;AACzB,UAAM,IAAI,MAAM,QAAQ,KAAK,IAAI,0BAA0B;AAAA,EAC7D;AAEA,MAAI,UAAU,KAAK,YAAY,UAAU,KAAK,MAAM;AAClD;AAAA,EACF;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA,qBAAqB,CAAC,gBAAgB;AACpC,kBAAY,YAAY,CAAC;AAEzB,UAAI,CAAC,YAAY,QAAQ,SAAS,KAAK,GAAG;AACxC,oBAAY,QAAQ,KAAK,KAAK;AAAA,MAChC;AAAA,IACF;AAAA,IACA;AAAA,IACA,uBAAuB;AAAA,IACvB;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,YAAY,QAA0C;AAC1E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,MAAI,CAAC,eAAe,UAAU,GAAG;AAC/B,UAAM,IAAI,MAAM,QAAQ,QAAQ,KAAK,UAAU,CAAC,0BAA0B;AAAA,EAC5E;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA,qBAAqB,CAAC,gBAAgB;AACpC,UAAI,CAAC,YAAY,SAAS;AACxB;AAAA,MACF;AAEA,kBAAY,UAAU,YAAY,QAAQ,OAAO,CAAC,MAAM,MAAM,KAAK;AAEnE,UAAI,YAAY,QAAQ,WAAW,GAAG;AACpC,eAAO,YAAY;AAAA,MACrB;AAAA,IACF;AAAA,IACA;AAAA,IACA,uBAAuB;AAAA,IACvB;AAAA,EACF,CAAC;AACH;AASA,eAAsB,mBAAgD,QAAoE;AACxI,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,IAAI;AACJ,MAAI,CAAC,eAAe,UAAU,GAAG;AAC/B,UAAM,IAAI,MAAM,QAAQ,QAAQ,KAAK,UAAU,CAAC,0BAA0B;AAAA,EAC5E;AAEA,QAAM,QAAQ,4BAA2C;AAAA,IACvD;AAAA,IACA,MAAM,mBAAmB,EAAE,aAAa,QAAQ,GAAG;AACjD,kBAAY,eAAe;AAE3B,YAAM,iBAAiB,iBAAoC,OAAO;AAClE,YAAM,iBAAiB,iBAAoC,OAAO;AAClE,YAAM,SAAS,MAAM,oBAAoB,gBAAgB,WAAW;AACpE,kBAAY,eAAe;AAE3B,UAAI,WAAW,MAAM;AACnB,eAAO;AAAA,MACT;AAEA,aAAO,YAAY,gBAAgB,cAAc,IAAI,UAAU,eAAe,SAAS,cAAc;AAAA,IACvG;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,CAAC,CAAC;AACJ;AAoBA,eAAsB,0BAA0B,KAAyB;AACvE,QAAM,0BAA0B;AAChC,QAAM,iBAAiB;AAAA,IACrB,mBAAmB,MAAM,IAAI,YAAY,sBAAsB;AAAA,IAC/D,eAAe;AAAA,IACf,cAAc;AAAA;AAAA,MAEZ,0BAA0B;AAAA,MAC1B,uBAAuB;AAAA,IACzB;AAAA,EACF,CAAC;AACH;",
  "names": []
}
