@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/obsidian-dev-utils-state.d.mts

@@ -0,0 +1,42 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Provides access to a process-wide shared-state bag used internally by `obsidian-dev-utils`.
+ *
+ * The bag is stored on `globalThis.__obsidianDevUtils`, i.e. on the global object of the realm in
+ * which `obsidian-dev-utils` is loaded. Because a function's `globalThis` resolves to its defining
+ * realm (not the caller's), every consumer that bundles the library in the main Obsidian renderer
+ * shares the same bag, regardless of which window is currently active. This intentionally replaces
+ * the previous `App`-scoped storage, so callers no longer need to pass an `App` instance.
+ *
+ * The generic, non-Obsidian state (the debuggers, the `debug` instance and the shared abort controller) lives in
+ * `typescript-lib-state.ts` instead. {@link shareTypescriptLibStateWithObsidianDevUtilsState} links the two, so
+ * plugins bundling an older copy of this library, which still keep that state here, share it with newer ones.
+ */
+import { ValueWrapper } from '@mnaoumov/typescript-lib/value-wrapper';
+/**
+ * Retrieves or creates a shared-state {@link ValueWrapper} for a given key on `globalThis.__obsidianDevUtils`.
+ *
+ * @typeParam T - The type of the shared state value.
+ * @param key - The key to store or retrieve the shared state under.
+ * @param defaultValue - The default value to use if the shared state does not exist yet.
+ * @returns The {@link ValueWrapper} that stores the shared state.
+ */
+export declare function getObsidianDevUtilsState<T>(key: string, defaultValue: T): ValueWrapper<T>;
+/**
+ * Clears the shared-state bag on `globalThis.__obsidianDevUtils`.
+ *
+ * Intended for test isolation: call it before each test so accumulated state (debuggers, queues,
+ * registered handlers, etc.) does not leak between tests.
+ */
+export declare function resetObsidianDevUtilsState(): void;
+/**
+ * Makes the generic shared state and `__obsidianDevUtils` hold the same {@link ValueWrapper} for each key that
+ * moved between them.
+ *
+ * A wrapper already under `__obsidianDevUtils` wins, because an older copy of this library loaded first and its
+ * callers already hold that instance. Otherwise the generic wrapper is published under `__obsidianDevUtils`, for
+ * older copies loaded later and for the devtools console.
+ */
+export declare function shareTypescriptLibStateWithObsidianDevUtilsState(): void;

package/dist/lib/esm/obsidian-dev-utils-state.mjs

@@ -0,0 +1,84 @@
+/*
+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 { getTypescriptLibStateSlot } from "@mnaoumov/typescript-lib/typescript-lib-state";
+import { ValueWrapper } from "@mnaoumov/typescript-lib/value-wrapper";
+const SHARED_WITH_TYPESCRIPT_LIB_STATE_KEYS = ["debug", "debuggers", "sharedAbortController"];
+function getObsidianDevUtilsState(key, defaultValue) {
+  return getObsidianDevUtilsBag()[key] ??= ValueWrapper.of(defaultValue);
+}
+function resetObsidianDevUtilsState() {
+  globalThis.__obsidianDevUtils = {};
+}
+function shareTypescriptLibStateWithObsidianDevUtilsState() {
+  const bag = getObsidianDevUtilsBag();
+  const values = getTypescriptLibStateSlot().values;
+  for (const key of SHARED_WITH_TYPESCRIPT_LIB_STATE_KEYS) {
+    const legacyWrapper = bag[key];
+    if (legacyWrapper) {
+      values[key] = legacyWrapper;
+      continue;
+    }
+    const wrapper = values[key];
+    if (wrapper) {
+      bag[key] = wrapper;
+    }
+  }
+}
+function getObsidianDevUtilsBag() {
+  const wrapper = globalThis;
+  wrapper.__obsidianDevUtils ??= {};
+  return wrapper.__obsidianDevUtils;
+}
+export {
+  getObsidianDevUtilsState,
+  resetObsidianDevUtilsState,
+  shareTypescriptLibStateWithObsidianDevUtilsState
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian-protocol-handler-registrar.d.mts

@@ -0,0 +1,55 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Obsidian protocol handler registrars.
+ */
+import type { ObsidianProtocolData, Plugin } from 'obsidian';
+import type { Promisable } from 'type-fest';
+/**
+ * A registrar for Obsidian protocol handlers.
+ */
+export interface ObsidianProtocolHandlerRegistrar {
+    /**
+     * Registers an Obsidian protocol handler.
+     *
+     * @param params - The parameters for the Obsidian protocol handler registration.
+     */
+    registerObsidianProtocolHandler: (params: ObsidianProtocolHandlerRegistrarRegisterObsidianProtocolHandlerParams) => void;
+}
+interface ObsidianProtocolHandlerRegistrarRegisterObsidianProtocolHandlerParams {
+    /**
+     * The action to register the handler for.
+     */
+    readonly action: string;
+    /**
+     * The handler to register.
+     *
+     * @param obsidianProtocolData - The data passed to the handler.
+     * @returns The result of the handler.
+     */
+    readonly handler: (obsidianProtocolData: ObsidianProtocolData) => Promisable<void>;
+}
+type PluginObsidianProtocolHandlerRegistrarRegisterObsidianProtocolHandlerParams = ObsidianProtocolHandlerRegistrarRegisterObsidianProtocolHandlerParams;
+/**
+ * Obsidian protocol handler registrar in an Obsidian plugin.
+ */
+export declare class PluginObsidianProtocolHandlerRegistrar implements ObsidianProtocolHandlerRegistrar {
+    /**
+     * The Obsidian plugin instance the protocol handlers are registered with.
+     */
+    protected readonly plugin: Plugin;
+    /**
+     * Creates a new instance of the {@link PluginObsidianProtocolHandlerRegistrar} class.
+     *
+     * @param plugin - The plugin to register the protocol handler with.
+     */
+    constructor(plugin: Plugin);
+    /**
+     * Registers an Obsidian protocol handler.
+     *
+     * @param params - The parameters for the Obsidian protocol handler registration.
+     */
+    registerObsidianProtocolHandler(params: PluginObsidianProtocolHandlerRegistrarRegisterObsidianProtocolHandlerParams): void;
+}
+export {};

package/dist/lib/esm/obsidian-protocol-handler-registrar.mjs

@@ -0,0 +1,76 @@
+/*
+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 { normalizePromisable } from "@mnaoumov/typescript-lib/async";
+class PluginObsidianProtocolHandlerRegistrar {
+  /**
+   * The Obsidian plugin instance the protocol handlers are registered with.
+   */
+  plugin;
+  /**
+   * Creates a new instance of the {@link PluginObsidianProtocolHandlerRegistrar} class.
+   *
+   * @param plugin - The plugin to register the protocol handler with.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  /**
+   * Registers an Obsidian protocol handler.
+   *
+   * @param params - The parameters for the Obsidian protocol handler registration.
+   */
+  registerObsidianProtocolHandler(params) {
+    this.plugin.registerObsidianProtocolHandler(params.action, (obsidianProtocolData) => normalizePromisable(params.handler(obsidianProtocolData)));
+  }
+}
+export {
+  PluginObsidianProtocolHandlerRegistrar
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian-settings.d.mts

@@ -0,0 +1,62 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides utility functions for working with Obsidian settings.
+ */
+import type { App } from 'obsidian';
+/**
+ * A way an input decides whether it is spell-checked.
+ *
+ * The `spellcheck` attribute is the whole mechanism: Obsidian never calls Electron's
+ * `setSpellCheckerEnabled`, it only sets the attribute per element. So `AlwaysOn` really does spell-check
+ * with `Editor > Spellcheck` off, and what it invokes is Chromium's built-in checker.
+ */
+export declare enum SpellcheckMode {
+    /**
+     * Always spell-check the input, whatever `Editor > Spellcheck` says.
+     */
+    AlwaysOn = "AlwaysOn",
+    /**
+     * Follow `Editor > Spellcheck`, the way Obsidian's own name-entry surfaces do — the inline note title,
+     * the file explorer's inline rename, the properties fields.
+     */
+    FollowObsidianSetting = "FollowObsidianSetting",
+    /**
+     * Never spell-check the input, whatever `Editor > Spellcheck` says.
+     */
+    Off = "Off"
+}
+/**
+ * A format of the new link.
+ */
+export type NewLinkFormat = 'absolute' | 'relative' | 'shortest';
+/**
+ * Retrieves whether to use relative links based on the Obsidian settings.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns Whether to use relative links.
+ */
+export declare function getNewLinkFormat(app: App): NewLinkFormat;
+/**
+ * Retrieves whether the spellcheck is enabled based on the Obsidian settings.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns Whether the spellcheck is enabled.
+ */
+export declare function isSpellcheckEnabled(app: App): boolean;
+/**
+ * Resolves a {@link SpellcheckMode} against the Obsidian settings.
+ *
+ * @param app - The Obsidian app instance.
+ * @param spellcheckMode - The mode to resolve.
+ * @returns Whether the input should be spell-checked.
+ */
+export declare function isSpellcheckEnabledForMode(app: App, spellcheckMode: SpellcheckMode): boolean;
+/**
+ * Retrieves whether to use wikilinks based on the Obsidian settings.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns Whether to use wikilinks.
+ */
+export declare function shouldUseWikilinks(app: App): boolean;

package/dist/lib/esm/obsidian-settings.mjs

@@ -0,0 +1,89 @@
+/*
+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 { assertNever } from "@mnaoumov/typescript-lib/type-guards";
+var SpellcheckMode = /* @__PURE__ */ ((SpellcheckMode2) => {
+  SpellcheckMode2["AlwaysOn"] = "AlwaysOn";
+  SpellcheckMode2["FollowObsidianSetting"] = "FollowObsidianSetting";
+  SpellcheckMode2["Off"] = "Off";
+  return SpellcheckMode2;
+})(SpellcheckMode || {});
+function getNewLinkFormat(app) {
+  return app.vault.getConfig("newLinkFormat");
+}
+function isSpellcheckEnabled(app) {
+  return Boolean(app.vault.getConfig("spellcheck"));
+}
+function isSpellcheckEnabledForMode(app, spellcheckMode) {
+  switch (spellcheckMode) {
+    case "AlwaysOn" /* AlwaysOn */: {
+      return true;
+    }
+    case "FollowObsidianSetting" /* FollowObsidianSetting */: {
+      return isSpellcheckEnabled(app);
+    }
+    case "Off" /* Off */: {
+      return false;
+    }
+    default: {
+      assertNever(spellcheckMode);
+    }
+  }
+}
+function shouldUseWikilinks(app) {
+  return !app.vault.getConfig("useMarkdownLinks");
+}
+export {
+  SpellcheckMode,
+  getNewLinkFormat,
+  isSpellcheckEnabled,
+  isSpellcheckEnabledForMode,
+  shouldUseWikilinks
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL29ic2lkaWFuLXNldHRpbmdzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogVGhpcyBtb2R1bGUgcHJvdmlkZXMgdXRpbGl0eSBmdW5jdGlvbnMgZm9yIHdvcmtpbmcgd2l0aCBPYnNpZGlhbiBzZXR0aW5ncy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IEFwcCB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgYXNzZXJ0TmV2ZXIgfSBmcm9tICdAbW5hb3Vtb3YvdHlwZXNjcmlwdC1saWIvdHlwZS1ndWFyZHMnO1xuXG4vKipcbiAqIEEgd2F5IGFuIGlucHV0IGRlY2lkZXMgd2hldGhlciBpdCBpcyBzcGVsbC1jaGVja2VkLlxuICpcbiAqIFRoZSBgc3BlbGxjaGVja2AgYXR0cmlidXRlIGlzIHRoZSB3aG9sZSBtZWNoYW5pc206IE9ic2lkaWFuIG5ldmVyIGNhbGxzIEVsZWN0cm9uJ3NcbiAqIGBzZXRTcGVsbENoZWNrZXJFbmFibGVkYCwgaXQgb25seSBzZXRzIHRoZSBhdHRyaWJ1dGUgcGVyIGVsZW1lbnQuIFNvIGBBbHdheXNPbmAgcmVhbGx5IGRvZXMgc3BlbGwtY2hlY2tcbiAqIHdpdGggYEVkaXRvciA+IFNwZWxsY2hlY2tgIG9mZiwgYW5kIHdoYXQgaXQgaW52b2tlcyBpcyBDaHJvbWl1bSdzIGJ1aWx0LWluIGNoZWNrZXIuXG4gKi9cbmV4cG9ydCBlbnVtIFNwZWxsY2hlY2tNb2RlIHtcbiAgLyoqXG4gICAqIEFsd2F5cyBzcGVsbC1jaGVjayB0aGUgaW5wdXQsIHdoYXRldmVyIGBFZGl0b3IgPiBTcGVsbGNoZWNrYCBzYXlzLlxuICAgKi9cbiAgQWx3YXlzT24gPSAnQWx3YXlzT24nLFxuXG4gIC8qKlxuICAgKiBGb2xsb3cgYEVkaXRvciA+IFNwZWxsY2hlY2tgLCB0aGUgd2F5IE9ic2lkaWFuJ3Mgb3duIG5hbWUtZW50cnkgc3VyZmFjZXMgZG8gXHUyMDE0IHRoZSBpbmxpbmUgbm90ZSB0aXRsZSxcbiAgICogdGhlIGZpbGUgZXhwbG9yZXIncyBpbmxpbmUgcmVuYW1lLCB0aGUgcHJvcGVydGllcyBmaWVsZHMuXG4gICAqL1xuICBGb2xsb3dPYnNpZGlhblNldHRpbmcgPSAnRm9sbG93T2JzaWRpYW5TZXR0aW5nJyxcblxuICAvKipcbiAgICogTmV2ZXIgc3BlbGwtY2hlY2sgdGhlIGlucHV0LCB3aGF0ZXZlciBgRWRpdG9yID4gU3BlbGxjaGVja2Agc2F5cy5cbiAgICovXG4gIE9mZiA9ICdPZmYnXG59XG5cbi8qKlxuICogQSBmb3JtYXQgb2YgdGhlIG5ldyBsaW5rLlxuICovXG5leHBvcnQgdHlwZSBOZXdMaW5rRm9ybWF0ID0gJ2Fic29sdXRlJyB8ICdyZWxhdGl2ZScgfCAnc2hvcnRlc3QnO1xuXG4vKipcbiAqIFJldHJpZXZlcyB3aGV0aGVyIHRvIHVzZSByZWxhdGl2ZSBsaW5rcyBiYXNlZCBvbiB0aGUgT2JzaWRpYW4gc2V0dGluZ3MuXG4gKlxuICogQHBhcmFtIGFwcCAtIFRoZSBPYnNpZGlhbiBhcHAgaW5zdGFuY2UuXG4gKiBAcmV0dXJucyBXaGV0aGVyIHRvIHVzZSByZWxhdGl2ZSBsaW5rcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldE5ld0xpbmtGb3JtYXQoYXBwOiBBcHApOiBOZXdMaW5rRm9ybWF0IHtcbiAgcmV0dXJuIGFwcC52YXVsdC5nZXRDb25maWcoJ25ld0xpbmtGb3JtYXQnKSBhcyBOZXdMaW5rRm9ybWF0O1xufVxuXG4vKipcbiAqIFJldHJpZXZlcyB3aGV0aGVyIHRoZSBzcGVsbGNoZWNrIGlzIGVuYWJsZWQgYmFzZWQgb24gdGhlIE9ic2lkaWFuIHNldHRpbmdzLlxuICpcbiAqIEBwYXJhbSBhcHAgLSBUaGUgT2JzaWRpYW4gYXBwIGluc3RhbmNlLlxuICogQHJldHVybnMgV2hldGhlciB0aGUgc3BlbGxjaGVjayBpcyBlbmFibGVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNTcGVsbGNoZWNrRW5hYmxlZChhcHA6IEFwcCk6IGJvb2xlYW4ge1xuICByZXR1cm4gQm9vbGVhbihhcHAudmF1bHQuZ2V0Q29uZmlnKCdzcGVsbGNoZWNrJykpO1xufVxuXG4vKipcbiAqIFJlc29sdmVzIGEge0BsaW5rIFNwZWxsY2hlY2tNb2RlfSBhZ2FpbnN0IHRoZSBPYnNpZGlhbiBzZXR0aW5ncy5cbiAqXG4gKiBAcGFyYW0gYXBwIC0gVGhlIE9ic2lkaWFuIGFwcCBpbnN0YW5jZS5cbiAqIEBwYXJhbSBzcGVsbGNoZWNrTW9kZSAtIFRoZSBtb2RlIHRvIHJlc29sdmUuXG4gKiBAcmV0dXJucyBXaGV0aGVyIHRoZSBpbnB1dCBzaG91bGQgYmUgc3BlbGwtY2hlY2tlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzU3BlbGxjaGVja0VuYWJsZWRGb3JNb2RlKGFwcDogQXBwLCBzcGVsbGNoZWNrTW9kZTogU3BlbGxjaGVja01vZGUpOiBib29sZWFuIHtcbiAgc3dpdGNoIChzcGVsbGNoZWNrTW9kZSkge1xuICAgIGNhc2UgU3BlbGxjaGVja01vZGUuQWx3YXlzT246IHtcbiAgICAgIHJldHVybiB0cnVlO1xuICAgIH1cbiAgICBjYXNlIFNwZWxsY2hlY2tNb2RlLkZvbGxvd09ic2lkaWFuU2V0dGluZzoge1xuICAgICAgcmV0dXJuIGlzU3BlbGxjaGVja0VuYWJsZWQoYXBwKTtcbiAgICB9XG4gICAgY2FzZSBTcGVsbGNoZWNrTW9kZS5PZmY6IHtcbiAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG4gICAgZGVmYXVsdDoge1xuICAgICAgYXNzZXJ0TmV2ZXIoc3BlbGxjaGVja01vZGUpO1xuICAgIH1cbiAgfVxufVxuXG4vKipcbiAqIFJldHJpZXZlcyB3aGV0aGVyIHRvIHVzZSB3aWtpbGlua3MgYmFzZWQgb24gdGhlIE9ic2lkaWFuIHNldHRpbmdzLlxuICpcbiAqIEBwYXJhbSBhcHAgLSBUaGUgT2JzaWRpYW4gYXBwIGluc3RhbmNlLlxuICogQHJldHVybnMgV2hldGhlciB0byB1c2Ugd2lraWxpbmtzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2hvdWxkVXNlV2lraWxpbmtzKGFwcDogQXBwKTogYm9vbGVhbiB7XG4gIHJldHVybiAhYXBwLnZhdWx0LmdldENvbmZpZygndXNlTWFya2Rvd25MaW5rcycpO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVFBLFNBQVMsbUJBQW1CO0FBU3JCLElBQUssaUJBQUwsa0JBQUtBLG9CQUFMO0FBSUwsRUFBQUEsZ0JBQUEsY0FBVztBQU1YLEVBQUFBLGdCQUFBLDJCQUF3QjtBQUt4QixFQUFBQSxnQkFBQSxTQUFNO0FBZkksU0FBQUE7QUFBQSxHQUFBO0FBNkJMLFNBQVMsaUJBQWlCLEtBQXlCO0FBQ3hELFNBQU8sSUFBSSxNQUFNLFVBQVUsZUFBZTtBQUM1QztBQVFPLFNBQVMsb0JBQW9CLEtBQW1CO0FBQ3JELFNBQU8sUUFBUSxJQUFJLE1BQU0sVUFBVSxZQUFZLENBQUM7QUFDbEQ7QUFTTyxTQUFTLDJCQUEyQixLQUFVLGdCQUF5QztBQUM1RixVQUFRLGdCQUFnQjtBQUFBLElBQ3RCLEtBQUssMkJBQXlCO0FBQzVCLGFBQU87QUFBQSxJQUNUO0FBQUEsSUFDQSxLQUFLLHFEQUFzQztBQUN6QyxhQUFPLG9CQUFvQixHQUFHO0FBQUEsSUFDaEM7QUFBQSxJQUNBLEtBQUssaUJBQW9CO0FBQ3ZCLGFBQU87QUFBQSxJQUNUO0FBQUEsSUFDQSxTQUFTO0FBQ1Asa0JBQVksY0FBYztBQUFBLElBQzVCO0FBQUEsRUFDRjtBQUNGO0FBUU8sU0FBUyxtQkFBbUIsS0FBbUI7QUFDcEQsU0FBTyxDQUFDLElBQUksTUFBTSxVQUFVLGtCQUFrQjtBQUNoRDsiLAogICJuYW1lcyI6IFsiU3BlbGxjaGVja01vZGUiXQp9Cg==