@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/esm/abort-controller.d.mts

@@ -0,0 +1,135 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * AbortController utilities.
+ */
+/**
+ * A constant representing an infinite timeout.
+ */
+export declare const INFINITE_TIMEOUT: number;
+/**
+ * An {@link AbortController} that can be aborted more than once.
+ *
+ * A plain {@link AbortController} is single-use: once aborted, its signal stays aborted forever, so it
+ * cannot back a cancel button that the user may press more than once. This one aborts the current signal
+ * and immediately replaces it, so the next operation starts with a fresh, non-aborted signal while the work
+ * that captured the previous signal still observes the abort.
+ *
+ * Read {@link ResettableAbortController.signal} at the start of each operation. Never cache it, or the
+ * operation after the first abort starts already aborted.
+ *
+ * @example
+ * ```typescript
+ * const resettableAbortController = new ResettableAbortController();
+ *
+ * await loop({
+ *   abortSignal: resettableAbortController.signal,
+ *   buildNoticeMessage: (file) => `Processing ${file.path}`,
+ *   items: app.vault.getMarkdownFiles(),
+ *   processItem: async (file) => { await processFile(file); }
+ * });
+ *
+ * // From a cancel button, a command, or the devtools console.
+ * resettableAbortController.abort();
+ * ```
+ *
+ * @see {@link getSharedAbortController} for the app-wide instance.
+ */
+export declare class ResettableAbortController {
+    /**
+     * The current abort signal.
+     *
+     * @returns The {@link AbortSignal} that aborts on the next {@link ResettableAbortController.abort} call.
+     */
+    get signal(): AbortSignal;
+    private abortController;
+    /**
+     * Aborts the current signal and replaces it with a fresh, non-aborted one.
+     *
+     * @param reason - The reason to abort with. When omitted, the signal is aborted with the native
+     * `AbortError` {@link DOMException}, exactly as {@link AbortController.abort} does.
+     */
+    abort(reason?: unknown): void;
+}
+/**
+ * An abort signal that aborts when any of the given abort signals abort.
+ *
+ * @param maybeAbortSignals - The abort signals to abort when any of them abort.
+ * @returns The abort signal that aborts when any of the given abort signals abort.
+ */
+export declare function abortSignalAny(...maybeAbortSignals: (AbortSignal | undefined)[]): AbortSignal;
+/**
+ * An abort signal that never aborts.
+ *
+ * @returns The abort signal that never aborts.
+ */
+export declare function abortSignalNever(): AbortSignal;
+/**
+ * An abort signal that aborts after a timeout.
+ *
+ * @param timeoutInMilliseconds - The timeout in milliseconds.
+ * @returns The abort signal that aborts after a timeout.
+ */
+export declare function abortSignalTimeout(timeoutInMilliseconds: number): AbortSignal;
+/**
+ * The app-wide shared {@link ResettableAbortController}.
+ *
+ * Every plugin built on this library shares one instance, so a single {@link ResettableAbortController.abort}
+ * call cancels whatever long-running operation is in flight, whichever plugin started it. A plugin that needs
+ * a cancel button of its own scope constructs its own {@link ResettableAbortController} instead.
+ *
+ * It lives in the shared state, so it is reachable from the devtools console:
+ *
+ * ```javascript
+ * globalThis[Symbol.for('@mnaoumov/typescript-lib/state')].values.sharedAbortController.value.abort();
+ * ```
+ *
+ * In an Obsidian plugin the same instance is also reachable as `__obsidianDevUtils.sharedAbortController.value`.
+ *
+ * @returns The shared {@link ResettableAbortController}.
+ */
+export declare function getSharedAbortController(): ResettableAbortController;
+/**
+ * The signal of the app-wide shared {@link ResettableAbortController}.
+ *
+ * Call it at the start of each operation. Never cache it, or the operation after the first abort starts
+ * already aborted.
+ *
+ * @example
+ * ```typescript
+ * await loop({
+ *   abortSignal: getSharedAbortSignal(),
+ *   buildNoticeMessage: (file) => `Processing ${file.path}`,
+ *   items: app.vault.getMarkdownFiles(),
+ *   processItem: async (file) => { await processFile(file); }
+ * });
+ * ```
+ *
+ * @returns The {@link AbortSignal} of the shared {@link ResettableAbortController}.
+ */
+export declare function getSharedAbortSignal(): AbortSignal;
+/**
+ * Adds an abort listener to an abort signal and calls the callback if the abort signal is already aborted.
+ *
+ * @param abortSignal - The abort signal to add the listener to.
+ * @param callback - The callback to call when the abort signal aborts.
+ * @returns A {@link Disposable} that removes the abort listener when disposed, for use with `using`.
+ */
+export declare function onAbort(abortSignal: AbortSignal, callback: (abortSignal: AbortSignal) => void): Disposable;
+/**
+ * Waits for an abort signal to abort and resolves with its reason.
+ *
+ * @typeParam T - Expected type of `abortSignal.reason`.
+ * @param abortSignal - The abort signal to wait for.
+ * @returns A {@link Promise} that resolves with the reason of the abort signal.
+ */
+export declare function waitForAbort<T = unknown>(abortSignal: AbortSignal): Promise<T>;
+/**
+ * Waits for an abort signal to abort and rejects with its reason.
+ *
+ * @param abortSignal - The abort signal to wait for.
+ * @param shouldRejectOnAbort - Whether to reject the promise if the abort signal is aborted.
+ * @returns A {@link Promise} that rejects with the reason of the abort signal.
+ */
+export declare function waitForAbort(abortSignal: AbortSignal, shouldRejectOnAbort: true): Promise<never>;

package/dist/lib/esm/abort-controller.mjs

@@ -0,0 +1,159 @@
+/*
+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 {
+  CallbackDisposable,
+  CombineDisposable
+} from "./disposable.mjs";
+import { noop } from "./function.mjs";
+import { getTypescriptLibState } from "./typescript-lib-state.mjs";
+const INFINITE_TIMEOUT = Infinity;
+class ResettableAbortController {
+  /**
+   * The current abort signal.
+   *
+   * @returns The {@link AbortSignal} that aborts on the next {@link ResettableAbortController.abort} call.
+   */
+  get signal() {
+    return this.abortController.signal;
+  }
+  abortController = new AbortController();
+  /**
+   * Aborts the current signal and replaces it with a fresh, non-aborted one.
+   *
+   * @param reason - The reason to abort with. When omitted, the signal is aborted with the native
+   * `AbortError` {@link DOMException}, exactly as {@link AbortController.abort} does.
+   */
+  abort(reason) {
+    this.abortController.abort(reason);
+    this.abortController = new AbortController();
+  }
+}
+function abortSignalAny(...maybeAbortSignals) {
+  const abortSignals = maybeAbortSignals.filter((abortSignal) => !!abortSignal);
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any(abortSignals);
+  }
+  if (abortSignals.length === 0) {
+    return abortSignalNever();
+  }
+  if (abortSignals.length === 1 && abortSignals[0]) {
+    return abortSignals[0];
+  }
+  const abortController = new AbortController();
+  for (const abortSignal of abortSignals) {
+    if (abortSignal.aborted) {
+      return abortSignal;
+    }
+  }
+  const abortHandlerDisposables = Array.from(abortSignals, (abortSignal) => onAbort(abortSignal, handleAbort));
+  const combinedAbortHandlerDisposable = new CombineDisposable({ disposables: abortHandlerDisposables });
+  return abortController.signal;
+  function handleAbort(abortSignal) {
+    combinedAbortHandlerDisposable.dispose();
+    abortController.abort(abortSignal.reason);
+  }
+}
+function abortSignalNever() {
+  return new AbortController().signal;
+}
+function abortSignalTimeout(timeoutInMilliseconds) {
+  if (timeoutInMilliseconds === INFINITE_TIMEOUT) {
+    return abortSignalNever();
+  }
+  const abortController = new AbortController();
+  globalThis.setTimeout(() => {
+    abortController.abort(new DOMException(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`, "TimeoutError"));
+  }, timeoutInMilliseconds);
+  return abortController.signal;
+}
+function getSharedAbortController() {
+  return getTypescriptLibState("sharedAbortController", new ResettableAbortController()).value;
+}
+function getSharedAbortSignal() {
+  return getSharedAbortController().signal;
+}
+function onAbort(abortSignal, callback) {
+  if (abortSignal.aborted) {
+    callback(abortSignal);
+    return new CallbackDisposable({ callback: noop });
+  }
+  abortSignal.addEventListener("abort", wrappedCallback, { once: true });
+  return new CallbackDisposable({
+    callback: () => {
+      abortSignal.removeEventListener("abort", wrappedCallback);
+    }
+  });
+  function wrappedCallback($event) {
+    callback($event.target);
+  }
+}
+function waitForAbort(abortSignal, shouldRejectOnAbort) {
+  return new Promise((resolve, reject) => {
+    onAbort(abortSignal, () => {
+      if (shouldRejectOnAbort) {
+        reject(abortSignal.reason);
+      } else {
+        resolve(abortSignal.reason);
+      }
+    });
+  });
+}
+export {
+  INFINITE_TIMEOUT,
+  ResettableAbortController,
+  abortSignalAny,
+  abortSignalNever,
+  abortSignalTimeout,
+  getSharedAbortController,
+  getSharedAbortSignal,
+  onAbort,
+  waitForAbort
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/abort-controller.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * AbortController utilities.\n */\n\nimport {\n  CallbackDisposable,\n  CombineDisposable\n} from './disposable.ts';\nimport { noop } from './function.ts';\nimport { getTypescriptLibState } from './typescript-lib-state.ts';\n\n/**\n * A constant representing an infinite timeout.\n */\nexport const INFINITE_TIMEOUT = Infinity;\n\n/**\n * An {@link AbortController} that can be aborted more than once.\n *\n * A plain {@link AbortController} is single-use: once aborted, its signal stays aborted forever, so it\n * cannot back a cancel button that the user may press more than once. This one aborts the current signal\n * and immediately replaces it, so the next operation starts with a fresh, non-aborted signal while the work\n * that captured the previous signal still observes the abort.\n *\n * Read {@link ResettableAbortController.signal} at the start of each operation. Never cache it, or the\n * operation after the first abort starts already aborted.\n *\n * @example\n * ```typescript\n * const resettableAbortController = new ResettableAbortController();\n *\n * await loop({\n *   abortSignal: resettableAbortController.signal,\n *   buildNoticeMessage: (file) => `Processing ${file.path}`,\n *   items: app.vault.getMarkdownFiles(),\n *   processItem: async (file) => { await processFile(file); }\n * });\n *\n * // From a cancel button, a command, or the devtools console.\n * resettableAbortController.abort();\n * ```\n *\n * @see {@link getSharedAbortController} for the app-wide instance.\n */\nexport class ResettableAbortController {\n  /**\n   * The current abort signal.\n   *\n   * @returns The {@link AbortSignal} that aborts on the next {@link ResettableAbortController.abort} call.\n   */\n  public get signal(): AbortSignal {\n    return this.abortController.signal;\n  }\n\n  private abortController = new AbortController();\n\n  /**\n   * Aborts the current signal and replaces it with a fresh, non-aborted one.\n   *\n   * @param reason - The reason to abort with. When omitted, the signal is aborted with the native\n   * `AbortError` {@link DOMException}, exactly as {@link AbortController.abort} does.\n   */\n  public abort(reason?: unknown): void {\n    this.abortController.abort(reason);\n    this.abortController = new AbortController();\n  }\n}\n\n/**\n * An abort signal that aborts when any of the given abort signals abort.\n *\n * @param maybeAbortSignals - The abort signals to abort when any of them abort.\n * @returns The abort signal that aborts when any of the given abort signals abort.\n */\nexport function abortSignalAny(...maybeAbortSignals: (AbortSignal | undefined)[]): AbortSignal {\n  const abortSignals = maybeAbortSignals.filter((abortSignal) => !!abortSignal);\n\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- `AbortSignal.any` is feature-detected here with a manual fallback below, so it is not required on older Obsidian/Electron (Chromium) versions that lack it.\n  if (typeof AbortSignal.any === 'function') {\n    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- `AbortSignal.any` is feature-detected by the guard above with a manual fallback below, so it is not required on older Obsidian/Electron (Chromium) versions that lack it.\n    return AbortSignal.any(abortSignals);\n  }\n\n  if (abortSignals.length === 0) {\n    return abortSignalNever();\n  }\n\n  if (abortSignals.length === 1 && abortSignals[0]) {\n    return abortSignals[0];\n  }\n\n  const abortController = new AbortController();\n\n  for (const abortSignal of abortSignals) {\n    if (abortSignal.aborted) {\n      return abortSignal;\n    }\n  }\n\n  const abortHandlerDisposables: Disposable[] = Array.from(abortSignals, (abortSignal) => onAbort(abortSignal, handleAbort));\n\n  const combinedAbortHandlerDisposable = new CombineDisposable({ disposables: abortHandlerDisposables });\n\n  return abortController.signal;\n\n  function handleAbort(abortSignal: AbortSignal): void {\n    combinedAbortHandlerDisposable.dispose();\n    abortController.abort(abortSignal.reason);\n  }\n}\n\n/**\n * An abort signal that never aborts.\n *\n * @returns The abort signal that never aborts.\n */\nexport function abortSignalNever(): AbortSignal {\n  return new AbortController().signal;\n}\n\n/**\n * An abort signal that aborts after a timeout.\n *\n * @param timeoutInMilliseconds - The timeout in milliseconds.\n * @returns The abort signal that aborts after a timeout.\n */\nexport function abortSignalTimeout(timeoutInMilliseconds: number): AbortSignal {\n  if (timeoutInMilliseconds === INFINITE_TIMEOUT) {\n    return abortSignalNever();\n  }\n\n  // Intentionally NOT the native `AbortSignal.timeout`, whose internal timer cannot be advanced by\n  // `vi.useFakeTimers()`, so `sleep` (its sole consumer) would be uncontrollable in tests. Building\n  // `sleep`'s signal off `globalThis.setTimeout` keeps it fake-timer controllable (like\n  // `setTimeoutAsync`) and also works in a Node environment where `window` is undefined, since\n  // `globalThis` exists in Node too. Consumer integration-test projects run vitest under\n  // `environment: 'node'`, in which a `window`-based primitive throws a `ReferenceError`.\n  // The abort reason mirrors the native one -- a `DOMException` named `TimeoutError` -- matching\n  // `AbortSignal.timeout` for `reason.name` checks.\n  const abortController = new AbortController();\n  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Intentional: `globalThis.setTimeout` (not `window`) so this timeout primitive also works in a Node environment where `window` is undefined; the specific window is irrelevant for a plain timer. The explicit `globalThis` is also what keeps the sibling `obsidianmd/prefer-window-timers` rule from rewriting it back to `window`.\n  globalThis.setTimeout(() => {\n    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- `DOMException` is a DOM global always present in the Obsidian/Electron (Chromium) runtime this code targets, and is also a Node global from Node 17 onward.\n    abortController.abort(new DOMException(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`, 'TimeoutError'));\n  }, timeoutInMilliseconds);\n  return abortController.signal;\n}\n\n/**\n * The app-wide shared {@link ResettableAbortController}.\n *\n * Every plugin built on this library shares one instance, so a single {@link ResettableAbortController.abort}\n * call cancels whatever long-running operation is in flight, whichever plugin started it. A plugin that needs\n * a cancel button of its own scope constructs its own {@link ResettableAbortController} instead.\n *\n * It lives in the shared state, so it is reachable from the devtools console:\n *\n * ```javascript\n * globalThis[Symbol.for('@mnaoumov/typescript-lib/state')].values.sharedAbortController.value.abort();\n * ```\n *\n * In an Obsidian plugin the same instance is also reachable as `__obsidianDevUtils.sharedAbortController.value`.\n *\n * @returns The shared {@link ResettableAbortController}.\n */\nexport function getSharedAbortController(): ResettableAbortController {\n  return getTypescriptLibState('sharedAbortController', new ResettableAbortController()).value;\n}\n\n/**\n * The signal of the app-wide shared {@link ResettableAbortController}.\n *\n * Call it at the start of each operation. Never cache it, or the operation after the first abort starts\n * already aborted.\n *\n * @example\n * ```typescript\n * await loop({\n *   abortSignal: getSharedAbortSignal(),\n *   buildNoticeMessage: (file) => `Processing ${file.path}`,\n *   items: app.vault.getMarkdownFiles(),\n *   processItem: async (file) => { await processFile(file); }\n * });\n * ```\n *\n * @returns The {@link AbortSignal} of the shared {@link ResettableAbortController}.\n */\nexport function getSharedAbortSignal(): AbortSignal {\n  return getSharedAbortController().signal;\n}\n\n/**\n * Adds an abort listener to an abort signal and calls the callback if the abort signal is already aborted.\n *\n * @param abortSignal - The abort signal to add the listener to.\n * @param callback - The callback to call when the abort signal aborts.\n * @returns A {@link Disposable} that removes the abort listener when disposed, for use with `using`.\n */\nexport function onAbort(abortSignal: AbortSignal, callback: (abortSignal: AbortSignal) => void): Disposable {\n  if (abortSignal.aborted) {\n    callback(abortSignal);\n    return new CallbackDisposable({ callback: noop });\n  }\n\n  abortSignal.addEventListener('abort', wrappedCallback, { once: true });\n  return new CallbackDisposable({\n    callback: (): void => {\n      abortSignal.removeEventListener('abort', wrappedCallback);\n    }\n  });\n\n  function wrappedCallback($event: Event): void {\n    callback($event.target as AbortSignal);\n  }\n}\n\n/**\n * Waits for an abort signal to abort and resolves with its reason.\n *\n * @typeParam T - Expected type of `abortSignal.reason`.\n * @param abortSignal - The abort signal to wait for.\n * @returns A {@link Promise} that resolves with the reason of the abort signal.\n */\nexport function waitForAbort<T = unknown>(abortSignal: AbortSignal): Promise<T>;\n/**\n * Waits for an abort signal to abort and rejects with its reason.\n *\n * @param abortSignal - The abort signal to wait for.\n * @param shouldRejectOnAbort - Whether to reject the promise if the abort signal is aborted.\n * @returns A {@link Promise} that rejects with the reason of the abort signal.\n */\nexport function waitForAbort(abortSignal: AbortSignal, shouldRejectOnAbort: true): Promise<never>;\n/**\n * Waits for an abort signal to abort and resolves with its reason.\n *\n * @typeParam T - Expected type of `abortSignal.reason`.\n * @param abortSignal - The abort signal to wait for.\n * @param shouldRejectOnAbort - Whether to reject the promise if the abort signal is aborted.\n * @returns A {@link Promise} that resolves with the reason of the abort signal.\n */\nexport function waitForAbort<T = unknown>(abortSignal: AbortSignal, shouldRejectOnAbort?: boolean): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    onAbort(abortSignal, () => {\n      if (shouldRejectOnAbort) {\n        reject(abortSignal.reason as Error);\n      } else {\n        resolve(abortSignal.reason as T);\n      }\n    });\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,6BAA6B;AAK/B,MAAM,mBAAmB;AA8BzB,MAAM,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrC,IAAW,SAAsB;AAC/B,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEQ,kBAAkB,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQvC,MAAM,QAAwB;AACnC,SAAK,gBAAgB,MAAM,MAAM;AACjC,SAAK,kBAAkB,IAAI,gBAAgB;AAAA,EAC7C;AACF;AAQO,SAAS,kBAAkB,mBAA6D;AAC7F,QAAM,eAAe,kBAAkB,OAAO,CAAC,gBAAgB,CAAC,CAAC,WAAW;AAG5E,MAAI,OAAO,YAAY,QAAQ,YAAY;AAEzC,WAAO,YAAY,IAAI,YAAY;AAAA,EACrC;AAEA,MAAI,aAAa,WAAW,GAAG;AAC7B,WAAO,iBAAiB;AAAA,EAC1B;AAEA,MAAI,aAAa,WAAW,KAAK,aAAa,CAAC,GAAG;AAChD,WAAO,aAAa,CAAC;AAAA,EACvB;AAEA,QAAM,kBAAkB,IAAI,gBAAgB;AAE5C,aAAW,eAAe,cAAc;AACtC,QAAI,YAAY,SAAS;AACvB,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,0BAAwC,MAAM,KAAK,cAAc,CAAC,gBAAgB,QAAQ,aAAa,WAAW,CAAC;AAEzH,QAAM,iCAAiC,IAAI,kBAAkB,EAAE,aAAa,wBAAwB,CAAC;AAErG,SAAO,gBAAgB;AAEvB,WAAS,YAAY,aAAgC;AACnD,mCAA+B,QAAQ;AACvC,oBAAgB,MAAM,YAAY,MAAM;AAAA,EAC1C;AACF;AAOO,SAAS,mBAAgC;AAC9C,SAAO,IAAI,gBAAgB,EAAE;AAC/B;AAQO,SAAS,mBAAmB,uBAA4C;AAC7E,MAAI,0BAA0B,kBAAkB;AAC9C,WAAO,iBAAiB;AAAA,EAC1B;AAUA,QAAM,kBAAkB,IAAI,gBAAgB;AAE5C,aAAW,WAAW,MAAM;AAE1B,oBAAgB,MAAM,IAAI,aAAa,gBAAgB,OAAO,qBAAqB,CAAC,iBAAiB,cAAc,CAAC;AAAA,EACtH,GAAG,qBAAqB;AACxB,SAAO,gBAAgB;AACzB;AAmBO,SAAS,2BAAsD;AACpE,SAAO,sBAAsB,yBAAyB,IAAI,0BAA0B,CAAC,EAAE;AACzF;AAoBO,SAAS,uBAAoC;AAClD,SAAO,yBAAyB,EAAE;AACpC;AASO,SAAS,QAAQ,aAA0B,UAA0D;AAC1G,MAAI,YAAY,SAAS;AACvB,aAAS,WAAW;AACpB,WAAO,IAAI,mBAAmB,EAAE,UAAU,KAAK,CAAC;AAAA,EAClD;AAEA,cAAY,iBAAiB,SAAS,iBAAiB,EAAE,MAAM,KAAK,CAAC;AACrE,SAAO,IAAI,mBAAmB;AAAA,IAC5B,UAAU,MAAY;AACpB,kBAAY,oBAAoB,SAAS,eAAe;AAAA,IAC1D;AAAA,EACF,CAAC;AAED,WAAS,gBAAgB,QAAqB;AAC5C,aAAS,OAAO,MAAqB;AAAA,EACvC;AACF;AA0BO,SAAS,aAA0B,aAA0B,qBAA2C;AAC7G,SAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACzC,YAAQ,aAAa,MAAM;AACzB,UAAI,qBAAqB;AACvB,eAAO,YAAY,MAAe;AAAA,MACpC,OAAO;AACL,gBAAQ,YAAY,MAAW;AAAA,MACjC;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/aggregate-error.d.mts

@@ -0,0 +1,24 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains a utility function for building an `AggregateError` that names what failed.
+ */
+/**
+ * Builds an `AggregateError` over collected errors, giving it a message that names what failed.
+ *
+ * `AggregateError`'s own message is optional, and omitting it is lossy in a way that only shows up
+ * outside this library. {@link error!errorToString} walks `errors` and prints the whole tree, so the
+ * console is fine; everything that reads `message` is not. Obsidian's own plugin-load failure report, a
+ * `Notice` built from an error, and a consumer's `rejects.toThrow(message)` all see an empty string and
+ * read it as "nothing was thrown". Nesting compounds it: an aggregate holding one aggregate puts two empty
+ * layers above the only sentence that says what went wrong.
+ *
+ * A single collected error therefore lends its own message to the aggregate, which makes a one-cause
+ * chain read identically at every level. Several become a count, with the detail one level down where
+ * {@link error!errorToString} already prints it.
+ *
+ * @param errors - The collected errors to aggregate.
+ * @returns An `AggregateError` holding every collected error, with a non-empty message.
+ */
+export declare function createAggregateError(errors: readonly unknown[]): AggregateError;

package/dist/lib/esm/aggregate-error.mjs

@@ -0,0 +1,60 @@
+/*
+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();
+})();
+})();
+
+function createAggregateError(errors) {
+  return new AggregateError(errors, getAggregateErrorMessage(errors));
+}
+function getAggregateErrorMessage(errors) {
+  const [singleError] = errors;
+  return errors.length === 1 && singleError instanceof Error && singleError.message !== "" ? singleError.message : `${String(errors.length)} error(s) occurred`;
+}
+export {
+  createAggregateError
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/array-buffer.d.mts

@@ -0,0 +1,16 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for {@link ArrayBuffer} objects.
+ */
+/**
+ * Copies bytes into a fresh {@link ArrayBuffer}.
+ *
+ * Reaching for `data.buffer` would be cheaper but wrong: its type is `ArrayBufferLike`, and the view may
+ * cover only part of a larger buffer, so the caller can end up handed bytes it never asked for.
+ *
+ * @param data - The bytes to copy.
+ * @returns An {@link ArrayBuffer} holding exactly those bytes.
+ */
+export declare function toArrayBuffer(data: Uint8Array): ArrayBuffer;

package/dist/lib/esm/array-buffer.mjs

@@ -0,0 +1,58 @@
+/*
+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();
+})();
+})();
+
+function toArrayBuffer(data) {
+  const buffer = new ArrayBuffer(data.byteLength);
+  new Uint8Array(buffer).set(data);
+  return buffer;
+}
+export {
+  toArrayBuffer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2FycmF5LWJ1ZmZlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIENvbnRhaW5zIHV0aWxpdHkgZnVuY3Rpb25zIGZvciB7QGxpbmsgQXJyYXlCdWZmZXJ9IG9iamVjdHMuXG4gKi9cblxuLyoqXG4gKiBDb3BpZXMgYnl0ZXMgaW50byBhIGZyZXNoIHtAbGluayBBcnJheUJ1ZmZlcn0uXG4gKlxuICogUmVhY2hpbmcgZm9yIGBkYXRhLmJ1ZmZlcmAgd291bGQgYmUgY2hlYXBlciBidXQgd3Jvbmc6IGl0cyB0eXBlIGlzIGBBcnJheUJ1ZmZlckxpa2VgLCBhbmQgdGhlIHZpZXcgbWF5XG4gKiBjb3ZlciBvbmx5IHBhcnQgb2YgYSBsYXJnZXIgYnVmZmVyLCBzbyB0aGUgY2FsbGVyIGNhbiBlbmQgdXAgaGFuZGVkIGJ5dGVzIGl0IG5ldmVyIGFza2VkIGZvci5cbiAqXG4gKiBAcGFyYW0gZGF0YSAtIFRoZSBieXRlcyB0byBjb3B5LlxuICogQHJldHVybnMgQW4ge0BsaW5rIEFycmF5QnVmZmVyfSBob2xkaW5nIGV4YWN0bHkgdGhvc2UgYnl0ZXMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0b0FycmF5QnVmZmVyKGRhdGE6IFVpbnQ4QXJyYXkpOiBBcnJheUJ1ZmZlciB7XG4gIGNvbnN0IGJ1ZmZlciA9IG5ldyBBcnJheUJ1ZmZlcihkYXRhLmJ5dGVMZW5ndGgpO1xuICBuZXcgVWludDhBcnJheShidWZmZXIpLnNldChkYXRhKTtcbiAgcmV0dXJuIGJ1ZmZlcjtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFlTyxTQUFTLGNBQWMsTUFBK0I7QUFDM0QsUUFBTSxTQUFTLElBQUksWUFBWSxLQUFLLFVBQVU7QUFDOUMsTUFBSSxXQUFXLE1BQU0sRUFBRSxJQUFJLElBQUk7QUFDL0IsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/array.d.mts

@@ -0,0 +1,46 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Array utilities.
+ */
+/**
+ * Filter an array in place.
+ *
+ * @typeParam T - The type of the array elements.
+ * @param array - The array to filter.
+ * @param shouldKeep - The predicate to filter the array.
+ */
+export declare function filterInPlace<T>(array: T[], shouldKeep: (value: T, index: number, array: T[]) => boolean): void;
+/**
+ * Copies an iterable into a new array, so it can be safely iterated while the original is modified.
+ *
+ * Use this whenever the loop body (or an awaited call inside it) adds to or removes from the collection
+ * being iterated — releasing locks, cancelling timers, settling pending operations. Iterating the live
+ * collection in those cases silently skips entries.
+ *
+ * Prefer this over an inline `[...collection]`: it says why the copy exists, and it keeps the call site
+ * clear of `unicorn/no-useless-spread`, which cannot tell a defensive copy from a redundant one.
+ *
+ * The result is `readonly`: it exists to be iterated, not worked on. Mutating it would change a throwaway
+ * copy and leave the original untouched, which is never what the caller wants.
+ *
+ * @typeParam T - The type of the elements.
+ * @param collection - The collection to copy.
+ * @returns A new array holding the collection's elements at the time of the call.
+ */
+export declare function snapshot<T>(collection: Iterable<T>): readonly T[];
+/**
+ * Remove duplicates from an array.
+ *
+ * @typeParam T - The type of the array elements.
+ * @param array - The array to remove duplicates from.
+ * @returns The array with duplicates removed.
+ */
+export declare function unique<T>(array: readonly T[]): T[];
+/**
+ * Remove duplicates from an array in place.
+ *
+ * @param array - The array to remove duplicates from.
+ */
+export declare function uniqueInPlace(array: unknown[]): void;

package/dist/lib/esm/array.mjs

@@ -0,0 +1,93 @@
+/*
+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();
+})();
+})();
+
+function filterInPlace(array, shouldKeep) {
+  const length = array.length;
+  let writeIndex = 0;
+  for (let readIndex = 0; readIndex < length; readIndex++) {
+    if (!Object.hasOwn(array, readIndex)) {
+      continue;
+    }
+    const current = array[readIndex];
+    if (shouldKeep(current, readIndex, array)) {
+      array[writeIndex++] = current;
+    }
+  }
+  array.length = writeIndex;
+}
+function snapshot(collection) {
+  return [...collection];
+}
+function unique(array) {
+  const set = /* @__PURE__ */ new Set();
+  return array.filter((value) => {
+    if (set.has(value)) {
+      return false;
+    }
+    set.add(value);
+    return true;
+  });
+}
+function uniqueInPlace(array) {
+  const set = /* @__PURE__ */ new Set();
+  filterInPlace(array, (value) => {
+    if (set.has(value)) {
+      return false;
+    }
+    set.add(value);
+    return true;
+  });
+}
+export {
+  filterInPlace,
+  snapshot,
+  unique,
+  uniqueInPlace
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2FycmF5LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQXJyYXkgdXRpbGl0aWVzLlxuICovXG5cbi8qKlxuICogRmlsdGVyIGFuIGFycmF5IGluIHBsYWNlLlxuICpcbiAqIEB0eXBlUGFyYW0gVCAtIFRoZSB0eXBlIG9mIHRoZSBhcnJheSBlbGVtZW50cy5cbiAqIEBwYXJhbSBhcnJheSAtIFRoZSBhcnJheSB0byBmaWx0ZXIuXG4gKiBAcGFyYW0gc2hvdWxkS2VlcCAtIFRoZSBwcmVkaWNhdGUgdG8gZmlsdGVyIHRoZSBhcnJheS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZpbHRlckluUGxhY2U8VD4oYXJyYXk6IFRbXSwgc2hvdWxkS2VlcDogKHZhbHVlOiBULCBpbmRleDogbnVtYmVyLCBhcnJheTogVFtdKSA9PiBib29sZWFuKTogdm9pZCB7XG4gIGNvbnN0IGxlbmd0aCA9IGFycmF5Lmxlbmd0aDtcbiAgbGV0IHdyaXRlSW5kZXggPSAwO1xuICBmb3IgKGxldCByZWFkSW5kZXggPSAwOyByZWFkSW5kZXggPCBsZW5ndGg7IHJlYWRJbmRleCsrKSB7XG4gICAgaWYgKCFPYmplY3QuaGFzT3duKGFycmF5LCByZWFkSW5kZXgpKSB7XG4gICAgICBjb250aW51ZTtcbiAgICB9XG5cbiAgICBjb25zdCBjdXJyZW50ID0gYXJyYXlbcmVhZEluZGV4XSBhcyBUO1xuICAgIGlmIChzaG91bGRLZWVwKGN1cnJlbnQsIHJlYWRJbmRleCwgYXJyYXkpKSB7XG4gICAgICBhcnJheVt3cml0ZUluZGV4KytdID0gY3VycmVudDtcbiAgICB9XG4gIH1cbiAgYXJyYXkubGVuZ3RoID0gd3JpdGVJbmRleDtcbn1cblxuLyoqXG4gKiBDb3BpZXMgYW4gaXRlcmFibGUgaW50byBhIG5ldyBhcnJheSwgc28gaXQgY2FuIGJlIHNhZmVseSBpdGVyYXRlZCB3aGlsZSB0aGUgb3JpZ2luYWwgaXMgbW9kaWZpZWQuXG4gKlxuICogVXNlIHRoaXMgd2hlbmV2ZXIgdGhlIGxvb3AgYm9keSAob3IgYW4gYXdhaXRlZCBjYWxsIGluc2lkZSBpdCkgYWRkcyB0byBvciByZW1vdmVzIGZyb20gdGhlIGNvbGxlY3Rpb25cbiAqIGJlaW5nIGl0ZXJhdGVkIFx1MjAxNCByZWxlYXNpbmcgbG9ja3MsIGNhbmNlbGxpbmcgdGltZXJzLCBzZXR0bGluZyBwZW5kaW5nIG9wZXJhdGlvbnMuIEl0ZXJhdGluZyB0aGUgbGl2ZVxuICogY29sbGVjdGlvbiBpbiB0aG9zZSBjYXNlcyBzaWxlbnRseSBza2lwcyBlbnRyaWVzLlxuICpcbiAqIFByZWZlciB0aGlzIG92ZXIgYW4gaW5saW5lIGBbLi4uY29sbGVjdGlvbl1gOiBpdCBzYXlzIHdoeSB0aGUgY29weSBleGlzdHMsIGFuZCBpdCBrZWVwcyB0aGUgY2FsbCBzaXRlXG4gKiBjbGVhciBvZiBgdW5pY29ybi9uby11c2VsZXNzLXNwcmVhZGAsIHdoaWNoIGNhbm5vdCB0ZWxsIGEgZGVmZW5zaXZlIGNvcHkgZnJvbSBhIHJlZHVuZGFudCBvbmUuXG4gKlxuICogVGhlIHJlc3VsdCBpcyBgcmVhZG9ubHlgOiBpdCBleGlzdHMgdG8gYmUgaXRlcmF0ZWQsIG5vdCB3b3JrZWQgb24uIE11dGF0aW5nIGl0IHdvdWxkIGNoYW5nZSBhIHRocm93YXdheVxuICogY29weSBhbmQgbGVhdmUgdGhlIG9yaWdpbmFsIHVudG91Y2hlZCwgd2hpY2ggaXMgbmV2ZXIgd2hhdCB0aGUgY2FsbGVyIHdhbnRzLlxuICpcbiAqIEB0eXBlUGFyYW0gVCAtIFRoZSB0eXBlIG9mIHRoZSBlbGVtZW50cy5cbiAqIEBwYXJhbSBjb2xsZWN0aW9uIC0gVGhlIGNvbGxlY3Rpb24gdG8gY29weS5cbiAqIEByZXR1cm5zIEEgbmV3IGFycmF5IGhvbGRpbmcgdGhlIGNvbGxlY3Rpb24ncyBlbGVtZW50cyBhdCB0aGUgdGltZSBvZiB0aGUgY2FsbC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNuYXBzaG90PFQ+KGNvbGxlY3Rpb246IEl0ZXJhYmxlPFQ+KTogcmVhZG9ubHkgVFtdIHtcbiAgcmV0dXJuIFsuLi5jb2xsZWN0aW9uXTtcbn1cblxuLyoqXG4gKiBSZW1vdmUgZHVwbGljYXRlcyBmcm9tIGFuIGFycmF5LlxuICpcbiAqIEB0eXBlUGFyYW0gVCAtIFRoZSB0eXBlIG9mIHRoZSBhcnJheSBlbGVtZW50cy5cbiAqIEBwYXJhbSBhcnJheSAtIFRoZSBhcnJheSB0byByZW1vdmUgZHVwbGljYXRlcyBmcm9tLlxuICogQHJldHVybnMgVGhlIGFycmF5IHdpdGggZHVwbGljYXRlcyByZW1vdmVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdW5pcXVlPFQ+KGFycmF5OiByZWFkb25seSBUW10pOiBUW10ge1xuICBjb25zdCBzZXQgPSBuZXcgU2V0PFQ+KCk7XG4gIHJldHVybiBhcnJheS5maWx0ZXIoKHZhbHVlKSA9PiB7XG4gICAgaWYgKHNldC5oYXModmFsdWUpKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICAgIHNldC5hZGQodmFsdWUpO1xuICAgIHJldHVybiB0cnVlO1xuICB9KTtcbn1cblxuLyoqXG4gKiBSZW1vdmUgZHVwbGljYXRlcyBmcm9tIGFuIGFycmF5IGluIHBsYWNlLlxuICpcbiAqIEBwYXJhbSBhcnJheSAtIFRoZSBhcnJheSB0byByZW1vdmUgZHVwbGljYXRlcyBmcm9tLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdW5pcXVlSW5QbGFjZShhcnJheTogdW5rbm93bltdKTogdm9pZCB7XG4gIGNvbnN0IHNldCA9IG5ldyBTZXQ8dW5rbm93bj4oKTtcbiAgZmlsdGVySW5QbGFjZShhcnJheSwgKHZhbHVlKSA9PiB7XG4gICAgaWYgKHNldC5oYXModmFsdWUpKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICAgIHNldC5hZGQodmFsdWUpO1xuICAgIHJldHVybiB0cnVlO1xuICB9KTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFhTyxTQUFTLGNBQWlCLE9BQVksWUFBb0U7QUFDL0csUUFBTSxTQUFTLE1BQU07QUFDckIsTUFBSSxhQUFhO0FBQ2pCLFdBQVMsWUFBWSxHQUFHLFlBQVksUUFBUSxhQUFhO0FBQ3ZELFFBQUksQ0FBQyxPQUFPLE9BQU8sT0FBTyxTQUFTLEdBQUc7QUFDcEM7QUFBQSxJQUNGO0FBRUEsVUFBTSxVQUFVLE1BQU0sU0FBUztBQUMvQixRQUFJLFdBQVcsU0FBUyxXQUFXLEtBQUssR0FBRztBQUN6QyxZQUFNLFlBQVksSUFBSTtBQUFBLElBQ3hCO0FBQUEsRUFDRjtBQUNBLFFBQU0sU0FBUztBQUNqQjtBQW1CTyxTQUFTLFNBQVksWUFBdUM7QUFDakUsU0FBTyxDQUFDLEdBQUcsVUFBVTtBQUN2QjtBQVNPLFNBQVMsT0FBVSxPQUEwQjtBQUNsRCxRQUFNLE1BQU0sb0JBQUksSUFBTztBQUN2QixTQUFPLE1BQU0sT0FBTyxDQUFDLFVBQVU7QUFDN0IsUUFBSSxJQUFJLElBQUksS0FBSyxHQUFHO0FBQ2xCLGFBQU87QUFBQSxJQUNUO0FBQ0EsUUFBSSxJQUFJLEtBQUs7QUFDYixXQUFPO0FBQUEsRUFDVCxDQUFDO0FBQ0g7QUFPTyxTQUFTLGNBQWMsT0FBd0I7QUFDcEQsUUFBTSxNQUFNLG9CQUFJLElBQWE7QUFDN0IsZ0JBQWMsT0FBTyxDQUFDLFVBQVU7QUFDOUIsUUFBSSxJQUFJLElBQUksS0FBSyxHQUFHO0FBQ2xCLGFBQU87QUFBQSxJQUNUO0FBQ0EsUUFBSSxJQUFJLEtBQUs7QUFDYixXQUFPO0FBQUEsRUFDVCxDQUFDO0FBQ0g7IiwKICAibmFtZXMiOiBbXQp9Cg==