@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/esm/data-handler.d.mts

@@ -3,8 +3,36 @@
  * @file
  *
  * A module for handling data loading and saving to the plugin's data file.
+ *
+ * {@link PluginDataHandler} bounds the plugin's `data.json` in bytes, in both directions, because Obsidian does
+ * not. Read from Obsidian `1.15.1`: `Plugin.loadData` reads the whole file and `JSON.parse`s it with no limit, so an
+ * oversized file is fully read and parsed into memory on every startup, and `Plugin.saveData` writes
+ * `JSON.stringify(data, undefined, 2)` with no limit either. Obsidian also swallows a failed read or write: its
+ * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard
+ * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the
+ * outcome.
  */
 import type { Plugin } from 'obsidian';
+/**
+ * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.
+ *
+ * This is a protective budget against startup exhaustion, not a sync quota. Obsidian Sync's own per-file limit
+ * depends on the plan and is a separate constraint a plugin may want to stay well under.
+ */
+export declare const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16777216;
+/**
+ * The operation a {@link PluginDataSizeLimitExceededError} refused.
+ */
+export declare enum PluginDataOperation {
+    /**
+     * Loading the existing `data.json`.
+     */
+    Load = "load",
+    /**
+     * Saving a new `data.json`.
+     */
+    Save = "save"
+}
 /**
  * A handler for loading and saving data to the plugin's data file.
  */
@@ -23,27 +51,125 @@ export interface DataHandler {
     readonly saveData: (data: unknown) => Promise<void>;
 }
 /**
- * A handler for loading and saving data to the plugin's data file.
+ * Options for {@link PluginDataHandler}.
+ */
+export interface PluginDataHandlerConstructorOptions {
+    /**
+     * The maximum size of `data.json`, in UTF-8 bytes as written to disk. Defaults to
+     * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.
+     */
+    readonly maxSizeInBytes?: number;
+}
+/**
+ * Parameters for {@link PluginDataSizeLimitExceededError}.
+ */
+export interface PluginDataSizeLimitExceededErrorConstructorParams {
+    /**
+     * The size limit, in bytes.
+     */
+    readonly maxSizeInBytes: number;
+    /**
+     * The refused operation.
+     */
+    readonly operation: PluginDataOperation;
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The size of the existing file (load) or of the serialized data (save), in bytes.
+     */
+    readonly sizeInBytes: number;
+}
+/**
+ * A handler for loading and saving data to the plugin's data file, refusing a `data.json` larger than a byte limit.
  */
 export declare class PluginDataHandler implements DataHandler {
     protected readonly plugin: Plugin;
+    /**
+     * The maximum size of `data.json`, in bytes.
+     */
+    protected readonly maxSizeInBytes: number;
     /**
      * Creates a new plugin data handler.
      *
      * @param plugin - The plugin instance.
+     * @param options - The options.
      */
-    constructor(plugin: Plugin);
+    constructor(plugin: Plugin, options?: PluginDataHandlerConstructorOptions);
     /**
      * Loads data from the plugin's data file.
      *
+     * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never
+     * loaded into memory.
+     *
      * @returns The loaded data.
+     * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
      */
     loadData(): Promise<unknown>;
     /**
      * Saves data to the plugin's data file.
      *
+     * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is
+     * written.
+     *
      * @param data - The data to save.
      * @returns A promise that resolves when the data is saved.
+     * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.
      */
     saveData(data: unknown): Promise<void>;
+    /**
+     * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.
+     *
+     * @returns The path, or `null` when the manifest has no folder.
+     */
+    protected getDataFilePath(): null | string;
+    private createError;
+    private getExistingFileSize;
+}
+/**
+ * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.
+ *
+ * The file on disk is never touched when this is thrown: an oversized existing file is left intact for the user to
+ * inspect or trim, and an oversized save is refused before anything is written, so the last good file remains.
+ */
+export declare class PluginDataSizeLimitExceededError extends Error {
+    /**
+     * The size limit, in bytes.
+     */
+    readonly maxSizeInBytes: number;
+    /**
+     * The refused operation.
+     */
+    readonly operation: PluginDataOperation;
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The size of the existing file (load) or of the serialized data (save), in bytes.
+     */
+    readonly sizeInBytes: number;
+    /**
+     * Creates a {@link PluginDataSizeLimitExceededError}.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: PluginDataSizeLimitExceededErrorConstructorParams);
 }

package/dist/lib/esm/data-handler.mjs

@@ -2,36 +2,184 @@
 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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
 
+ensureBrowserProcess();
+})();
+
+import { normalizePath } from "obsidian";
+const OBSIDIAN_JSON_INDENT = 2;
+const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16777216;
+var PluginDataOperation = /* @__PURE__ */ ((PluginDataOperation2) => {
+  PluginDataOperation2["Load"] = "load";
+  PluginDataOperation2["Save"] = "save";
+  return PluginDataOperation2;
+})(PluginDataOperation || {});
 class PluginDataHandler {
   /**
    * Creates a new plugin data handler.
    *
    * @param plugin - The plugin instance.
+   * @param options - The options.
    */
-  constructor(plugin) {
+  constructor(plugin, options = {}) {
     this.plugin = plugin;
+    const maxSizeInBytes = options.maxSizeInBytes ?? DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES;
+    if (Number.isNaN(maxSizeInBytes) || maxSizeInBytes < 0) {
+      throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);
+    }
+    this.maxSizeInBytes = maxSizeInBytes;
   }
   plugin;
+  /**
+   * The maximum size of `data.json`, in bytes.
+   */
+  maxSizeInBytes;
   /**
    * Loads data from the plugin's data file.
    *
+   * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never
+   * loaded into memory.
+   *
    * @returns The loaded data.
+   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
    */
   async loadData() {
+    const sizeInBytes = await this.getExistingFileSize();
+    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {
+      throw this.createError("load" /* Load */, sizeInBytes);
+    }
     return this.plugin.loadData();
   }
   /**
    * Saves data to the plugin's data file.
    *
+   * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is
+   * written.
+   *
    * @param data - The data to save.
    * @returns A promise that resolves when the data is saved.
+   * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.
    */
   async saveData(data) {
-    return this.plugin.saveData(data);
+    if (this.maxSizeInBytes !== Infinity) {
+      const serialized = JSON.stringify(data, void 0, OBSIDIAN_JSON_INDENT);
+      if (serialized !== void 0) {
+        const sizeInBytes = new TextEncoder().encode(serialized).byteLength;
+        if (sizeInBytes > this.maxSizeInBytes) {
+          throw this.createError("save" /* Save */, sizeInBytes);
+        }
+      }
+    }
+    await this.plugin.saveData(data);
+  }
+  /**
+   * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.
+   *
+   * @returns The path, or `null` when the manifest has no folder.
+   */
+  getDataFilePath() {
+    const directory = this.plugin.manifest.dir;
+    return directory ? normalizePath(`${directory}/data.json`) : null;
+  }
+  createError(operation, sizeInBytes) {
+    return new PluginDataSizeLimitExceededError({
+      maxSizeInBytes: this.maxSizeInBytes,
+      operation,
+      path: this.getDataFilePath() ?? "data.json",
+      pluginId: this.plugin.manifest.id,
+      pluginName: this.plugin.manifest.name,
+      sizeInBytes
+    });
+  }
+  async getExistingFileSize() {
+    if (this.maxSizeInBytes === Infinity) {
+      return null;
+    }
+    const path = this.getDataFilePath();
+    if (path === null) {
+      return null;
+    }
+    try {
+      const stat = await this.plugin.app.vault.adapter.stat(path);
+      return stat?.size ?? null;
+    } catch {
+      return null;
+    }
+  }
+}
+class PluginDataSizeLimitExceededError extends Error {
+  /**
+   * The size limit, in bytes.
+   */
+  maxSizeInBytes;
+  /**
+   * The refused operation.
+   */
+  operation;
+  /**
+   * The path of the plugin's `data.json`.
+   */
+  path;
+  /**
+   * The `manifest.id` of the plugin.
+   */
+  pluginId;
+  /**
+   * The `manifest.name` of the plugin.
+   */
+  pluginName;
+  /**
+   * The size of the existing file (load) or of the serialized data (save), in bytes.
+   */
+  sizeInBytes;
+  /**
+   * Creates a {@link PluginDataSizeLimitExceededError}.
+   *
+   * @param params - The parameters for the error.
+   */
+  constructor(params) {
+    const what = params.operation === "load" /* Load */ ? `Refusing to load "${params.path}": the file is ${String(params.sizeInBytes)} bytes` : `Refusing to save "${params.path}": the data would be ${String(params.sizeInBytes)} bytes`;
+    const consequence = params.operation === "load" /* Load */ ? "The file was left untouched." : "Nothing was written, so the last saved file remains.";
+    super(
+      `Plugin "${params.pluginName}" (${params.pluginId}): ${what}, over the ${String(params.maxSizeInBytes)}-byte limit. ${consequence} Keep data.json for small settings, and move large or growing state to LocalDataStore or SharedDataStore.`
+    );
+    this.name = "PluginDataSizeLimitExceededError";
+    this.maxSizeInBytes = params.maxSizeInBytes;
+    this.operation = params.operation;
+    this.path = params.path;
+    this.pluginId = params.pluginId;
+    this.pluginName = params.pluginName;
+    this.sizeInBytes = params.sizeInBytes;
   }
 }
 export {
-  PluginDataHandler
+  DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES,
+  PluginDataHandler,
+  PluginDataOperation,
+  PluginDataSizeLimitExceededError
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/data-handler.ts"],"sourcesContent":["/**\n * @file\n *\n * A module for handling data loading and saving to the plugin's data file.\n *\n * {@link PluginDataHandler} bounds the plugin's `data.json` in bytes, in both directions, because Obsidian does\n * not. Read from Obsidian `1.15.1`: `Plugin.loadData` reads the whole file and `JSON.parse`s it with no limit, so an\n * oversized file is fully read and parsed into memory on every startup, and `Plugin.saveData` writes\n * `JSON.stringify(data, undefined, 2)` with no limit either. Obsidian also swallows a failed read or write: its\n * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard\n * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the\n * outcome.\n */\n\nimport type { Plugin } from 'obsidian';\n\nimport { normalizePath } from 'obsidian';\n\n/**\n * The indentation Obsidian's `Vault.writeJson` passes to `JSON.stringify` for `data.json` (read from `1.15.1`).\n */\nconst OBSIDIAN_JSON_INDENT = 2;\n\n/**\n * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.\n *\n * This is a protective budget against startup exhaustion, not a sync quota. Obsidian Sync's own per-file limit\n * depends on the plan and is a separate constraint a plugin may want to stay well under.\n */\nexport const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16_777_216;\n\n/**\n * The operation a {@link PluginDataSizeLimitExceededError} refused.\n */\nexport enum PluginDataOperation {\n  /**\n   * Loading the existing `data.json`.\n   */\n  Load = 'load',\n\n  /**\n   * Saving a new `data.json`.\n   */\n  Save = 'save'\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file.\n */\nexport interface DataHandler {\n  /**\n   * A function to load data from the plugin's data file.\n   *\n   * @returns The loaded data.\n   */\n  readonly loadData: () => Promise<unknown>;\n\n  /**\n   * A function to save data to the plugin's data file.\n   *\n   * @param data - The data to save.\n   */\n  readonly saveData: (data: unknown) => Promise<void>;\n}\n\n/**\n * Options for {@link PluginDataHandler}.\n */\nexport interface PluginDataHandlerConstructorOptions {\n  /**\n   * The maximum size of `data.json`, in UTF-8 bytes as written to disk. Defaults to\n   * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.\n   */\n  readonly maxSizeInBytes?: number;\n}\n\n/**\n * Parameters for {@link PluginDataSizeLimitExceededError}.\n */\nexport interface PluginDataSizeLimitExceededErrorConstructorParams {\n  /**\n   * The size limit, in bytes.\n   */\n  readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  readonly sizeInBytes: number;\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file, refusing a `data.json` larger than a byte limit.\n */\nexport class PluginDataHandler implements DataHandler {\n  /**\n   * The maximum size of `data.json`, in bytes.\n   */\n  protected readonly maxSizeInBytes: number;\n\n  /**\n   * Creates a new plugin data handler.\n   *\n   * @param plugin - The plugin instance.\n   * @param options - The options.\n   */\n  public constructor(protected readonly plugin: Plugin, options: PluginDataHandlerConstructorOptions = {}) {\n    const maxSizeInBytes = options.maxSizeInBytes ?? DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES;\n    if (Number.isNaN(maxSizeInBytes) || maxSizeInBytes < 0) {\n      throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);\n    }\n    this.maxSizeInBytes = maxSizeInBytes;\n  }\n\n  /**\n   * Loads data from the plugin's data file.\n   *\n   * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never\n   * loaded into memory.\n   *\n   * @returns The loaded data.\n   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.\n   */\n  public async loadData(): Promise<unknown> {\n    const sizeInBytes = await this.getExistingFileSize();\n    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {\n      throw this.createError(PluginDataOperation.Load, sizeInBytes);\n    }\n    return this.plugin.loadData();\n  }\n\n  /**\n   * Saves data to the plugin's data file.\n   *\n   * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is\n   * written.\n   *\n   * @param data - The data to save.\n   * @returns A promise that resolves when the data is saved.\n   * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.\n   */\n  public async saveData(data: unknown): Promise<void> {\n    if (this.maxSizeInBytes !== Infinity) {\n      // Obsidian's `writeJson` would swallow a serialization failure and write nothing; throwing here instead keeps\n      // the disk unchanged too, and tells the caller.\n      const serialized = JSON.stringify(data, undefined, OBSIDIAN_JSON_INDENT);\n      if (serialized !== undefined) {\n        const sizeInBytes = new TextEncoder().encode(serialized).byteLength;\n        if (sizeInBytes > this.maxSizeInBytes) {\n          throw this.createError(PluginDataOperation.Save, sizeInBytes);\n        }\n      }\n    }\n    await this.plugin.saveData(data);\n  }\n\n  /**\n   * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.\n   *\n   * @returns The path, or `null` when the manifest has no folder.\n   */\n  protected getDataFilePath(): null | string {\n    const directory = this.plugin.manifest.dir;\n    return directory ? normalizePath(`${directory}/data.json`) : null;\n  }\n\n  private createError(operation: PluginDataOperation, sizeInBytes: number): PluginDataSizeLimitExceededError {\n    return new PluginDataSizeLimitExceededError({\n      maxSizeInBytes: this.maxSizeInBytes,\n      operation,\n      path: this.getDataFilePath() ?? 'data.json',\n      pluginId: this.plugin.manifest.id,\n      pluginName: this.plugin.manifest.name,\n      sizeInBytes\n    });\n  }\n\n  private async getExistingFileSize(): Promise<null | number> {\n    if (this.maxSizeInBytes === Infinity) {\n      return null;\n    }\n    const path = this.getDataFilePath();\n    if (path === null) {\n      return null;\n    }\n    try {\n      const stat = await this.plugin.app.vault.adapter.stat(path);\n      return stat?.size ?? null;\n    } catch {\n      // The size is unknown, not oversized: Obsidian's own read decides what happens next, as before this guard.\n      return null;\n    }\n  }\n}\n\n/**\n * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.\n *\n * The file on disk is never touched when this is thrown: an oversized existing file is left intact for the user to\n * inspect or trim, and an oversized save is refused before anything is written, so the last good file remains.\n */\nexport class PluginDataSizeLimitExceededError extends Error {\n  /**\n   * The size limit, in bytes.\n   */\n  public readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  public readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  public readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  public readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  public readonly sizeInBytes: number;\n\n  /**\n   * Creates a {@link PluginDataSizeLimitExceededError}.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: PluginDataSizeLimitExceededErrorConstructorParams) {\n    const what = params.operation === PluginDataOperation.Load\n      ? `Refusing to load \"${params.path}\": the file is ${String(params.sizeInBytes)} bytes`\n      : `Refusing to save \"${params.path}\": the data would be ${String(params.sizeInBytes)} bytes`;\n    const consequence = params.operation === PluginDataOperation.Load\n      ? 'The file was left untouched.'\n      : 'Nothing was written, so the last saved file remains.';\n    super(\n      `Plugin \"${params.pluginName}\" (${params.pluginId}): ${what}, over the ${String(params.maxSizeInBytes)}-byte limit. ${consequence} `\n        + 'Keep data.json for small settings, and move large or growing state to LocalDataStore or SharedDataStore.'\n    );\n    this.name = 'PluginDataSizeLimitExceededError';\n    this.maxSizeInBytes = params.maxSizeInBytes;\n    this.operation = params.operation;\n    this.path = params.path;\n    this.pluginId = params.pluginId;\n    this.pluginName = params.pluginName;\n    this.sizeInBytes = params.sizeInBytes;\n  }\n}\n"],"mappings":"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","names":["PluginDataOperation"]}

package/dist/lib/esm/desktop-git-runner.d.mts

@@ -2,14 +2,20 @@
 /**
  * @file
  *
- * Desktop git runner with Node modules loaded only when a command runs.
+ * Desktop git runner.
+ *
+ * Desktop-only (`node:child_process`, `node:util`), but inert to import on mobile: nothing here reads either
+ * module until the runner executes a command. The imports are static on purpose. A plugin ships one CommonJS
+ * `main.js`, and esbuild turns a static import of an external module into a `require()`, which Obsidian's renderer
+ * serves, while it keeps a dynamic `import('node:child_process')` as a native `import()`, which the renderer
+ * cannot load. That failed every command, and `loadGitRenames` answered no renames at all.
  */
 import type { GitRunner } from './git-rename-history.mjs';
 /**
  * Creates a {@link GitRunner} for a folder.
  *
  * Call the runner only on desktop, behind `Platform.isDesktopApp`. Importing this module and creating a
- * runner are safe on mobile: Node modules load only when the runner executes a command.
+ * runner are safe on mobile: Node modules are read only when the runner executes a command.
  *
  * @param cwd - The folder to run `git` in.
  * @returns The runner.

package/dist/lib/esm/desktop-git-runner.mjs

@@ -3,11 +3,11 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 const GIT_OUTPUT_LIMIT_IN_BYTES = 268435456;
 function createDesktopGitRunner(cwd) {
   return async (arguments_) => {
-    const { execFile } = await import("node:child_process");
-    const { promisify } = await import("node:util");
     const execFileAsync = promisify(execFile);
     const { stdout } = await execFileAsync("git", [...arguments_], { cwd, encoding: "utf-8", maxBuffer: GIT_OUTPUT_LIMIT_IN_BYTES, windowsHide: true });
     return stdout;
@@ -16,4 +16,4 @@ function createDesktopGitRunner(cwd) {
 export {
   createDesktopGitRunner
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2Rlc2t0b3AtZ2l0LXJ1bm5lci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIERlc2t0b3AgZ2l0IHJ1bm5lciB3aXRoIE5vZGUgbW9kdWxlcyBsb2FkZWQgb25seSB3aGVuIGEgY29tbWFuZCBydW5zLlxuICovXG5cbmltcG9ydCB0eXBlIHsgR2l0UnVubmVyIH0gZnJvbSAnLi9naXQtcmVuYW1lLWhpc3RvcnkudHMnO1xuXG4vKipcbiAqIExhcmdlIGVub3VnaCBmb3IgdGhlIHJlbmFtZSBoaXN0b3J5IG9mIGFueSB2YXVsdDogYC0tZGlmZi1maWx0ZXI9UmAga2VlcHMgb25seSB0aGUgcmVuYW1lcy4gMjU2IE1pQi5cbiAqL1xuY29uc3QgR0lUX09VVFBVVF9MSU1JVF9JTl9CWVRFUyA9IDI2OF80MzVfNDU2O1xuXG4vKipcbiAqIENyZWF0ZXMgYSB7QGxpbmsgR2l0UnVubmVyfSBmb3IgYSBmb2xkZXIuXG4gKlxuICogQ2FsbCB0aGUgcnVubmVyIG9ubHkgb24gZGVza3RvcCwgYmVoaW5kIGBQbGF0Zm9ybS5pc0Rlc2t0b3BBcHBgLiBJbXBvcnRpbmcgdGhpcyBtb2R1bGUgYW5kIGNyZWF0aW5nIGFcbiAqIHJ1bm5lciBhcmUgc2FmZSBvbiBtb2JpbGU6IE5vZGUgbW9kdWxlcyBsb2FkIG9ubHkgd2hlbiB0aGUgcnVubmVyIGV4ZWN1dGVzIGEgY29tbWFuZC5cbiAqXG4gKiBAcGFyYW0gY3dkIC0gVGhlIGZvbGRlciB0byBydW4gYGdpdGAgaW4uXG4gKiBAcmV0dXJucyBUaGUgcnVubmVyLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlRGVza3RvcEdpdFJ1bm5lcihjd2Q6IHN0cmluZyk6IEdpdFJ1bm5lciB7XG4gIHJldHVybiBhc3luYyAoYXJndW1lbnRzXykgPT4ge1xuICAgIGNvbnN0IHsgZXhlY0ZpbGUgfSA9IGF3YWl0IGltcG9ydCgnbm9kZTpjaGlsZF9wcm9jZXNzJyk7XG4gICAgY29uc3QgeyBwcm9taXNpZnkgfSA9IGF3YWl0IGltcG9ydCgnbm9kZTp1dGlsJyk7XG4gICAgY29uc3QgZXhlY0ZpbGVBc3luYyA9IHByb21pc2lmeShleGVjRmlsZSk7XG4gICAgY29uc3QgeyBzdGRvdXQgfSA9IGF3YWl0IGV4ZWNGaWxlQXN5bmMoJ2dpdCcsIFsuLi5hcmd1bWVudHNfXSwgeyBjd2QsIGVuY29kaW5nOiAndXRmLTgnLCBtYXhCdWZmZXI6IEdJVF9PVVRQVVRfTElNSVRfSU5fQllURVMsIHdpbmRvd3NIaWRlOiB0cnVlIH0pO1xuICAgIHJldHVybiBzdGRvdXQ7XG4gIH07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQVdBLE1BQU0sNEJBQTRCO0FBVzNCLFNBQVMsdUJBQXVCLEtBQXdCO0FBQzdELFNBQU8sT0FBTyxlQUFlO0FBQzNCLFVBQU0sRUFBRSxTQUFTLElBQUksTUFBTSxPQUFPLG9CQUFvQjtBQUN0RCxVQUFNLEVBQUUsVUFBVSxJQUFJLE1BQU0sT0FBTyxXQUFXO0FBQzlDLFVBQU0sZ0JBQWdCLFVBQVUsUUFBUTtBQUN4QyxVQUFNLEVBQUUsT0FBTyxJQUFJLE1BQU0sY0FBYyxPQUFPLENBQUMsR0FBRyxVQUFVLEdBQUcsRUFBRSxLQUFLLFVBQVUsU0FBUyxXQUFXLDJCQUEyQixhQUFhLEtBQUssQ0FBQztBQUNsSixXQUFPO0FBQUEsRUFDVDtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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