obsidian-dev-utils 74.1.0 → 75.0.0

package/dist/lib/esm/obsidian/components/monkey-around-component.d.mts

@@ -13,9 +13,46 @@ import { ComponentEx } from './component-ex.mjs';
  *
  * @typeParam Obj - The object to patch.
  */
-export type Factories<Obj extends object> = Partial<{
-    [Key in ConditionalKeys<Obj, GenericFunction | undefined>]: WrapperFactory<Extract<Obj[Key], GenericFunction | undefined>>;
-}>;
+export type Factories<Obj extends object> = Partial<FullFactories<Obj>>;
+/**
+ * Keys of `Obj` whose value is callable — a method, or a function-like object such as a `Debouncer`. These are the members
+ * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.
+ *
+ * @typeParam Obj - The object whose keys are filtered.
+ */
+export type FunctionKeys<Obj extends object> = ConditionalKeys<Obj, GenericFunction | undefined> & keyof Obj;
+/**
+ * Keys of `Obj` whose value is a plain function (a "real method"). Function-like objects that carry extra members are
+ * excluded — e.g. a `Debouncer` (which adds `cancel`/`run`) belongs to {@link MonkeyAroundComponent#registerFunctionPatch},
+ * not {@link MonkeyAroundComponent#registerMethodPatch}. The check is whether the member has any own keys beyond a bare
+ * function's (`Exclude<keyof T, keyof GenericFunction>` is `never`).
+ *
+ * @typeParam Obj - The object whose keys are filtered.
+ */
+export type MethodKeys<Obj extends object> = MethodKeysMap<Obj>[FunctionKeys<Obj>];
+/**
+ * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.
+ *
+ * @typeParam Obj - The object to patch.
+ * @typeParam FunctionName - The function name to patch.
+ */
+export interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends object, FunctionName extends FunctionKeys<Obj>> {
+    /**
+     * The function name to patch.
+     */
+    readonly functionName: FunctionName;
+    /**
+     * The object to patch.
+     */
+    readonly obj: Obj;
+    /**
+     * Patch handler function that takes the original value and returns the patched value.
+     *
+     * @param originalValue - The original value of the function.
+     * @returns The patched value of the function.
+     */
+    patchHandler(originalValue: Obj[FunctionName]): Obj[FunctionName];
+}
 /**
  * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.
  *
@@ -100,14 +137,26 @@ export interface PostPatchHandlerParams<Obj extends object, MethodName extends M
     readonly patchedMethod: ExtractFunction<Obj, MethodName>;
 }
 type ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;
-type MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;
+type FullFactories<Obj extends object> = {
+    [Key in keyof Obj]: (originalValue: Obj[Key]) => Obj[Key];
+};
+type MethodKeysMap<Obj extends object> = {
+    [Key in FunctionKeys<Obj>]: [Exclude<keyof NonNullable<Obj[Key]>, keyof GenericFunction>] extends [never] ? Key : never;
+};
 type Uninstaller = () => void;
-type WrapperFactory<T extends Function | undefined> = (next: T) => T;
 /**
  * A component that manages monkey-patches with lifecycle-bound cleanup.
  * All patches registered via this component are automatically uninstalled when the component unloads.
  */
 export declare class MonkeyAroundComponent extends ComponentEx {
+    /**
+     * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.
+     *
+     * @typeParam Obj - The object to patch.
+     * @typeParam FunctionName - The function name to patch.
+     * @param params - The parameters of the patch.
+     */
+    registerFunctionPatch<Obj extends object, const FunctionName extends FunctionKeys<Obj>>(params: MonkeyAroundComponentRegisterFunctionPatchParams<Obj, FunctionName>): void;
     /**
      * Registers a single-method patch using a simplified handler.
      *

package/dist/lib/esm/obsidian/components/monkey-around-component.mjs

@@ -22,9 +22,24 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { around as originalAround } from "monkey-around";
-import { getObsidianDevUtilsState } from "../app.mjs";
+import { getObsidianDevUtilsState } from "../../obsidian-dev-utils-state.mjs";
 import { ComponentEx } from "./component-ex.mjs";
 class MonkeyAroundComponent extends ComponentEx {
+  /**
+   * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.
+   *
+   * @typeParam Obj - The object to patch.
+   * @typeParam FunctionName - The function name to patch.
+   * @param params - The parameters of the patch.
+   */
+  registerFunctionPatch(params) {
+    this.ensureLoaded();
+    const factories = {};
+    factories[params.functionName] = (originalValue) => {
+      return params.patchHandler(originalValue);
+    };
+    this.registerPatch(params.obj, factories);
+  }
   /**
    * Registers a single-method patch using a simplified handler.
    *
@@ -38,12 +53,16 @@ class MonkeyAroundComponent extends ComponentEx {
       const originalMethod = params.obj[params.methodName];
       getMonkeyAroundPatches().set(originalMethod, params.patchToken);
     }
-    this.registerPatch(params.obj, {
-      [params.methodName]: (originalMethod) => {
-        return params.postPatchHandler?.({
+    this.registerFunctionPatch({
+      functionName: params.methodName,
+      obj: params.obj,
+      patchHandler: (originalMethodRaw) => {
+        const originalMethod = originalMethodRaw;
+        const finalPatchedMethod = params.postPatchHandler?.({
           originalMethod,
           patchedMethod
         }) ?? patchedMethod;
+        return finalPatchedMethod;
         function patchedMethod(...originalArgs) {
           const originalThis = this;
           return params.patchHandler({
@@ -79,11 +98,11 @@ function hasPatchToken(fn, patchToken) {
   return getMonkeyAroundPatches().get(fn) === patchToken;
 }
 function getMonkeyAroundPatches() {
-  return getObsidianDevUtilsState(null, "monkeyAroundPatches", /* @__PURE__ */ new WeakMap()).value;
+  return getObsidianDevUtilsState("monkeyAroundPatches", /* @__PURE__ */ new WeakMap()).value;
 }
 export {
   MonkeyAroundComponent,
   around,
   hasPatchToken
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type { MaybeReturn } from '../../type.ts';\n\nimport { getObsidianDevUtilsState } from '../app.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<\n  {\n    [Key in ConditionalKeys<Obj, GenericFunction | undefined>]: WrapperFactory<Extract<Obj[Key], GenericFunction | undefined>>;\n  }\n>;\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, MethodName>\n) => ReturnType<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.\n   */\n  readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PostPatchHandlerParams<Obj, MethodName>\n) => MaybeReturn<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The patched method.\n   */\n  readonly patchedMethod: ExtractFunction<Obj, MethodName>;\n}\n\ntype ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype WrapperFactory<T extends Function | undefined> = (next: T) => T;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type Fn = ExtractFunction<Obj, MethodName>;\n\n    this.registerPatch(params.obj, {\n      [params.methodName]: (originalMethod: Fn): Fn => {\n        return params.postPatchHandler?.({\n          originalMethod,\n          patchedMethod\n        }) ?? patchedMethod;\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<Fn>): ReturnType<Fn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    } as Factories<Obj>);\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState(null, 'monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,UAAU,sBAAsB;AAMzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AAkIrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,cAAc,OAAO,KAAK;AAAA,MAC7B,CAAC,OAAO,UAAU,GAAG,CAAC,mBAA2B;AAC/C,eAAO,OAAO,mBAAmB;AAAA,UAC/B;AAAA,UACA;AAAA,QACF,CAAC,KAAK;AACN,iBAAS,iBAA4B,cAA8C;AAEjF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAmB;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,SAAO,eAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,SAAO,yBAAyB,MAAM,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACvG;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type { MaybeReturn } from '../../type.ts';\n\nimport { getObsidianDevUtilsState } from '../../obsidian-dev-utils-state.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<FullFactories<Obj>>;\n\n/**\n * Keys of `Obj` whose value is callable \u2014 a method, or a function-like object such as a `Debouncer`. These are the members\n * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam Obj - The object whose keys are filtered.\n */\nexport type FunctionKeys<Obj extends object> = ConditionalKeys<Obj, GenericFunction | undefined> & keyof Obj;\n\n/**\n * Keys of `Obj` whose value is a plain function (a \"real method\"). Function-like objects that carry extra members are\n * excluded \u2014 e.g. a `Debouncer` (which adds `cancel`/`run`) belongs to {@link MonkeyAroundComponent#registerFunctionPatch},\n * not {@link MonkeyAroundComponent#registerMethodPatch}. The check is whether the member has any own keys beyond a bare\n * function's (`Exclude<keyof T, keyof GenericFunction>` is `never`).\n *\n * @typeParam Obj - The object whose keys are filtered.\n */\nexport type MethodKeys<Obj extends object> = MethodKeysMap<Obj>[FunctionKeys<Obj>];\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam FunctionName - The function name to patch.\n */\nexport interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends object, FunctionName extends FunctionKeys<Obj>> {\n  /**\n   * The function name to patch.\n   */\n  readonly functionName: FunctionName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * Patch handler function that takes the original value and returns the patched value.\n   *\n   * @param originalValue - The original value of the function.\n   * @returns The patched value of the function.\n   */\n  patchHandler(originalValue: Obj[FunctionName]): Obj[FunctionName];\n}\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, MethodName>\n) => ReturnType<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.\n   */\n  readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PostPatchHandlerParams<Obj, MethodName>\n) => MaybeReturn<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The patched method.\n   */\n  readonly patchedMethod: ExtractFunction<Obj, MethodName>;\n}\n\ntype ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;\n\ntype FullFactories<Obj extends object> = {\n  [Key in keyof Obj]: (originalValue: Obj[Key]) => Obj[Key];\n};\n\ntype MethodKeysMap<Obj extends object> = {\n  [Key in FunctionKeys<Obj>]: [Exclude<keyof NonNullable<Obj[Key]>, keyof GenericFunction>] extends [never] ? Key : never;\n};\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam FunctionName - The function name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerFunctionPatch<Obj extends object, const FunctionName extends FunctionKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterFunctionPatchParams<Obj, FunctionName>\n  ): void {\n    this.ensureLoaded();\n\n    const factories: Factories<Obj> = {};\n    factories[params.functionName] = (originalValue: Obj[FunctionName]): Obj[FunctionName] => {\n      return params.patchHandler(originalValue);\n    };\n\n    this.registerPatch(params.obj, factories);\n  }\n\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type Fn = ExtractFunction<Obj, MethodName>;\n\n    this.registerFunctionPatch({\n      functionName: params.methodName,\n      obj: params.obj,\n      patchHandler: (originalMethodRaw) => {\n        const originalMethod = originalMethodRaw as Fn;\n        const finalPatchedMethod = params.postPatchHandler?.({\n          originalMethod,\n          patchedMethod\n        }) ?? patchedMethod;\n        return finalPatchedMethod as Obj[MethodName];\n\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<Fn>): ReturnType<Fn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    });\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState('monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,UAAU,sBAAsB;AAMzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AA4KrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,sBACL,QACM;AACN,SAAK,aAAa;AAElB,UAAM,YAA4B,CAAC;AACnC,cAAU,OAAO,YAAY,IAAI,CAAC,kBAAwD;AACxF,aAAO,OAAO,aAAa,aAAa;AAAA,IAC1C;AAEA,SAAK,cAAc,OAAO,KAAK,SAAS;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,sBAAsB;AAAA,MACzB,cAAc,OAAO;AAAA,MACrB,KAAK,OAAO;AAAA,MACZ,cAAc,CAAC,sBAAsB;AACnC,cAAM,iBAAiB;AACvB,cAAM,qBAAqB,OAAO,mBAAmB;AAAA,UACnD;AAAA,UACA;AAAA,QACF,CAAC,KAAK;AACN,eAAO;AAEP,iBAAS,iBAA4B,cAA8C;AAEjF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,SAAO,eAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,SAAO,yBAAyB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACjG;",
  "names": []
}


package/dist/lib/esm/obsidian/components/plugin-context-component.mjs

@@ -44,7 +44,7 @@ class PluginContextComponent extends ComponentEx {
    * Initializes the plugin context and debug controller.
    */
   onload() {
-    initPluginContext(this.app, this.pluginId);
+    initPluginContext(this.pluginId);
     this.addChild(new AllWindowsEventComponent(this.app)).registerAllWindowsHandler((win) => {
       initDebugController(win, this);
     });
@@ -53,4 +53,4 @@ class PluginContextComponent extends ComponentEx {
 export {
   PluginContextComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/plugin-notice-component.mjs

@@ -22,7 +22,7 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { Notice } from "obsidian";
-import { getObsidianDevUtilsState } from "../app.mjs";
+import { getObsidianDevUtilsState } from "../../obsidian-dev-utils-state.mjs";
 import { ComponentEx } from "./component-ex.mjs";
 const PERMANENT_NOTICES_STATE_KEY = "plugin-notice-component:permanent-notices";
 const PERMANENT_NOTICE_DURATION_IN_MILLISECONDS = 0;
@@ -77,7 +77,7 @@ class PluginNoticeComponent extends ComponentEx {
     return this.getPermanentNotices().get(this.pluginName) ?? null;
   }
   getPermanentNotices() {
-    return getObsidianDevUtilsState(null, PERMANENT_NOTICES_STATE_KEY, /* @__PURE__ */ new Map()).value;
+    return getObsidianDevUtilsState(PERMANENT_NOTICES_STATE_KEY, /* @__PURE__ */ new Map()).value;
   }
   setPermanentNotice(notice) {
     const map = this.getPermanentNotices();
@@ -98,4 +98,4 @@ function prependPrefix(prefix, message) {
 export {
   PluginNoticeComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbXBvbmVudHMvcGx1Z2luLW5vdGljZS1jb21wb25lbnQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDb21wb25lbnQgdGhhdCBtYW5hZ2VzIGRpc3BsYXlpbmcgbm90aWNlcyB0byB0aGUgdXNlci5cbiAqL1xuXG5pbXBvcnQgeyBOb3RpY2UgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB7IGdldE9ic2lkaWFuRGV2VXRpbHNTdGF0ZSB9IGZyb20gJy4uLy4uL29ic2lkaWFuLWRldi11dGlscy1zdGF0ZS50cyc7XG5pbXBvcnQgeyBDb21wb25lbnRFeCB9IGZyb20gJy4vY29tcG9uZW50LWV4LnRzJztcblxuY29uc3QgUEVSTUFORU5UX05PVElDRVNfU1RBVEVfS0VZID0gJ3BsdWdpbi1ub3RpY2UtY29tcG9uZW50OnBlcm1hbmVudC1ub3RpY2VzJztcbmNvbnN0IFBFUk1BTkVOVF9OT1RJQ0VfRFVSQVRJT05fSU5fTUlMTElTRUNPTkRTID0gMDtcblxuLyoqXG4gKiBPcHRpb25zIGZvciB7QGxpbmsgUGx1Z2luTm90aWNlQ29tcG9uZW50LnNob3dOb3RpY2V9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBsdWdpbk5vdGljZUNvbXBvbmVudFNob3dOb3RpY2VPcHRpb25zIHtcbiAgLyoqXG4gICAqIFdoZXRoZXIgdGhlIG5vdGljZSBzaG91bGQgc3RheSB1bnRpbCBpdCBpcyByZXBsYWNlZCwgdGhlIHBsdWdpbiBpcyByZWxvYWRlZCwgb3IgdGhlIHVzZXIgZGlzbWlzc2VzIGl0LiBEZWZhdWx0cyB0b1xuICAgKiBgZmFsc2VgLlxuICAgKlxuICAgKiBBIHBlcm1hbmVudCBub3RpY2UgaXMgc2hvd24gd2l0aCBhbiBpbmZpbml0ZSBkdXJhdGlvbiBhbmQgaXMgbm90IGhpZGRlbiB3aGVuIHRoZSBjb21wb25lbnQgdW5sb2Fkcywgc28gaXQgY2FuXG4gICAqIGNvbW11bmljYXRlIHN0YXRlIHRoYXQgb3V0bGl2ZXMgdGhlIHBsdWdpbiAoZS5nLiBhIGNsZWFudXAgdGhhdCByZXF1aXJlcyBhIHJlbG9hZCkuIFRoZXJlIGlzIGF0IG1vc3Qgb25lIHBlcm1hbmVudFxuICAgKiBub3RpY2UgcGVyIHBsdWdpbjogaXQgaXMgaGlkZGVuIGJ5IHRoZSBuZXh0IHtAbGluayBQbHVnaW5Ob3RpY2VDb21wb25lbnQuc2hvd05vdGljZX0gY2FsbCBhbmQgZGlzbWlzc2VkXG4gICAqIGF1dG9tYXRpY2FsbHkgdGhlIG5leHQgdGltZSB0aGUgY29tcG9uZW50IGxvYWRzIChpLmUuIHdoZW4gdGhlIHBsdWdpbiBpcyByZS1lbmFibGVkKS5cbiAgICovXG4gIHJlYWRvbmx5IGlzUGVybWFuZW50PzogYm9vbGVhbjtcbn1cblxuLyoqXG4gKiBNYW5hZ2VzIHNob3dpbmcgcGx1Z2luIG5vdGljZXMuIEF1dG9tYXRpY2FsbHkgaGlkZXMgdGhlIHByZXZpb3VzIG5vdGljZSB3aGVuIGEgbmV3IG9uZSBpcyBzaG93bi5cbiAqL1xuZXhwb3J0IGNsYXNzIFBsdWdpbk5vdGljZUNvbXBvbmVudCBleHRlbmRzIENvbXBvbmVudEV4IHtcbiAgcHJpdmF0ZSBub3RpY2U6IE5vdGljZSB8IG51bGwgPSBudWxsO1xuXG4gIC8qKlxuICAgKiBDcmVhdGVzIGEgbmV3IHBsdWdpbiBub3RpY2UgY29tcG9uZW50LlxuICAgKlxuICAgKiBAcGFyYW0gcGx1Z2luTmFtZSAtIFRoZSBwbHVnaW4gbmFtZSAoc2hvd24gYXMgcHJlZml4IGluIG5vdGljZXMpLlxuICAgKi9cbiAgcHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgcGx1Z2luTmFtZTogc3RyaW5nKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBEaXNtaXNzZXMgdGhlIHBlcm1hbmVudCBub3RpY2UgbGVmdCBvdmVyIGZyb20gYSBwcmV2aW91cyBsb2FkIChlLmcuIGEgcHJldmlvdXMgcGx1Z2luIHNlc3Npb24pIG9uIGxvYWQuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgb25sb2FkKCk6IHZvaWQge1xuICAgIHN1cGVyLm9ubG9hZCgpO1xuICAgIGNvbnN0IHBlcm1hbmVudE5vdGljZSA9IHRoaXMuZ2V0UGVybWFuZW50Tm90aWNlKCk7XG4gICAgcGVybWFuZW50Tm90aWNlPy5oaWRlKCk7XG4gICAgdGhpcy5zZXRQZXJtYW5lbnROb3RpY2UobnVsbCk7XG4gIH1cblxuICAvKipcbiAgICogSGlkZXMgdGhlIGN1cnJlbnQgbm90aWNlIG9uIHVubG9hZCwgdW5sZXNzIGl0IGlzIHRoZSBwZXJtYW5lbnQgbm90aWNlICh3aGljaCBpcyBtZWFudCB0byBvdXRsaXZlIHRoZSBwbHVnaW4pLlxuICAgKi9cbiAgcHVibGljIG92ZXJyaWRlIG9udW5sb2FkKCk6IHZvaWQge1xuICAgIGlmICh0aGlzLmdldFBlcm1hbmVudE5vdGljZSgpICE9PSB0aGlzLm5vdGljZSkge1xuICAgICAgdGhpcy5ub3RpY2U/LmhpZGUoKTtcbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogRGlzcGxheXMgYSBub3RpY2UgbWVzc2FnZSB0byB0aGUgdXNlci5cbiAgICpcbiAgICogQHBhcmFtIG1lc3NhZ2UgLSBUaGUgbWVzc2FnZSB0byBkaXNwbGF5LlxuICAgKiBAcGFyYW0gb3B0aW9ucyAtIFRoZSBvcHRpb25zIGZvciBkaXNwbGF5aW5nIHRoZSBub3RpY2UuXG4gICAqL1xuICBwdWJsaWMgc2hvd05vdGljZShtZXNzYWdlOiBEb2N1bWVudEZyYWdtZW50IHwgc3RyaW5nLCBvcHRpb25zPzogUGx1Z2luTm90aWNlQ29tcG9uZW50U2hvd05vdGljZU9wdGlvbnMpOiB2b2lkIHtcbiAgICB0aGlzLm5vdGljZT8uaGlkZSgpO1xuXG4gICAgY29uc3QgcHJlZml4ID0gYCR7dGhpcy5wbHVnaW5OYW1lfSR7dGhpcy5fbG9hZGVkID8gJycgOiAnICh1bmxvYWRlZCknfVxcbmA7XG4gICAgY29uc3QgcHJlZml4ZWRNZXNzYWdlID0gcHJlcGVuZFByZWZpeChwcmVmaXgsIG1lc3NhZ2UpO1xuICAgIHRoaXMubm90aWNlID0gbmV3IE5vdGljZShwcmVmaXhlZE1lc3NhZ2UsIG9wdGlvbnM/LmlzUGVybWFuZW50ID8gUEVSTUFORU5UX05PVElDRV9EVVJBVElPTl9JTl9NSUxMSVNFQ09ORFMgOiB1bmRlZmluZWQpO1xuXG4gICAgaWYgKG9wdGlvbnM/LmlzUGVybWFuZW50KSB7XG4gICAgICB0aGlzLnNldFBlcm1hbmVudE5vdGljZSh0aGlzLm5vdGljZSk7XG4gICAgfSBlbHNlIHtcbiAgICAgIHRoaXMuc2V0UGVybWFuZW50Tm90aWNlKG51bGwpO1xuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgZ2V0UGVybWFuZW50Tm90aWNlKCk6IE5vdGljZSB8IG51bGwge1xuICAgIHJldHVybiB0aGlzLmdldFBlcm1hbmVudE5vdGljZXMoKS5nZXQodGhpcy5wbHVnaW5OYW1lKSA/PyBudWxsO1xuICB9XG5cbiAgcHJpdmF0ZSBnZXRQZXJtYW5lbnROb3RpY2VzKCk6IE1hcDxzdHJpbmcsIE5vdGljZT4ge1xuICAgIHJldHVybiBnZXRPYnNpZGlhbkRldlV0aWxzU3RhdGU8TWFwPHN0cmluZywgTm90aWNlPj4oUEVSTUFORU5UX05PVElDRVNfU1RBVEVfS0VZLCBuZXcgTWFwPHN0cmluZywgTm90aWNlPigpKS52YWx1ZTtcbiAgfVxuXG4gIHByaXZhdGUgc2V0UGVybWFuZW50Tm90aWNlKG5vdGljZTogTm90aWNlIHwgbnVsbCk6IHZvaWQge1xuICAgIGNvbnN0IG1hcCA9IHRoaXMuZ2V0UGVybWFuZW50Tm90aWNlcygpO1xuICAgIGlmIChub3RpY2UpIHtcbiAgICAgIG1hcC5zZXQodGhpcy5wbHVnaW5OYW1lLCBub3RpY2UpO1xuICAgIH0gZWxzZSB7XG4gICAgICBtYXAuZGVsZXRlKHRoaXMucGx1Z2luTmFtZSk7XG4gICAgfVxuICB9XG59XG5cbmZ1bmN0aW9uIHByZXBlbmRQcmVmaXgocHJlZml4OiBzdHJpbmcsIG1lc3NhZ2U6IERvY3VtZW50RnJhZ21lbnQgfCBzdHJpbmcpOiBEb2N1bWVudEZyYWdtZW50IHwgc3RyaW5nIHtcbiAgaWYgKHR5cGVvZiBtZXNzYWdlID09PSAnc3RyaW5nJykge1xuICAgIHJldHVybiBgJHtwcmVmaXh9JHttZXNzYWdlfWA7XG4gIH1cblxuICBtZXNzYWdlLnByZXBlbmQocHJlZml4KTtcbiAgcmV0dXJuIG1lc3NhZ2U7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQU1BLFNBQVMsY0FBYztBQUV2QixTQUFTLGdDQUFnQztBQUN6QyxTQUFTLG1CQUFtQjtBQUU1QixNQUFNLDhCQUE4QjtBQUNwQyxNQUFNLDRDQUE0QztBQXFCM0MsTUFBTSw4QkFBOEIsWUFBWTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVE5QyxZQUE2QixZQUFvQjtBQUN0RCxVQUFNO0FBRDRCO0FBQUEsRUFFcEM7QUFBQSxFQUZvQztBQUFBLEVBUDVCLFNBQXdCO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFjaEIsU0FBZTtBQUM3QixVQUFNLE9BQU87QUFDYixVQUFNLGtCQUFrQixLQUFLLG1CQUFtQjtBQUNoRCxxQkFBaUIsS0FBSztBQUN0QixTQUFLLG1CQUFtQixJQUFJO0FBQUEsRUFDOUI7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQUtnQixXQUFpQjtBQUMvQixRQUFJLEtBQUssbUJBQW1CLE1BQU0sS0FBSyxRQUFRO0FBQzdDLFdBQUssUUFBUSxLQUFLO0FBQUEsSUFDcEI7QUFBQSxFQUNGO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFRTyxXQUFXLFNBQW9DLFNBQXdEO0FBQzVHLFNBQUssUUFBUSxLQUFLO0FBRWxCLFVBQU0sU0FBUyxHQUFHLEtBQUssVUFBVSxHQUFHLEtBQUssVUFBVSxLQUFLLGFBQWE7QUFBQTtBQUNyRSxVQUFNLGtCQUFrQixjQUFjLFFBQVEsT0FBTztBQUNyRCxTQUFLLFNBQVMsSUFBSSxPQUFPLGlCQUFpQixTQUFTLGNBQWMsNENBQTRDLE1BQVM7QUFFdEgsUUFBSSxTQUFTLGFBQWE7QUFDeEIsV0FBSyxtQkFBbUIsS0FBSyxNQUFNO0FBQUEsSUFDckMsT0FBTztBQUNMLFdBQUssbUJBQW1CLElBQUk7QUFBQSxJQUM5QjtBQUFBLEVBQ0Y7QUFBQSxFQUVRLHFCQUFvQztBQUMxQyxXQUFPLEtBQUssb0JBQW9CLEVBQUUsSUFBSSxLQUFLLFVBQVUsS0FBSztBQUFBLEVBQzVEO0FBQUEsRUFFUSxzQkFBMkM7QUFDakQsV0FBTyx5QkFBOEMsNkJBQTZCLG9CQUFJLElBQW9CLENBQUMsRUFBRTtBQUFBLEVBQy9HO0FBQUEsRUFFUSxtQkFBbUIsUUFBNkI7QUFDdEQsVUFBTSxNQUFNLEtBQUssb0JBQW9CO0FBQ3JDLFFBQUksUUFBUTtBQUNWLFVBQUksSUFBSSxLQUFLLFlBQVksTUFBTTtBQUFBLElBQ2pDLE9BQU87QUFDTCxVQUFJLE9BQU8sS0FBSyxVQUFVO0FBQUEsSUFDNUI7QUFBQSxFQUNGO0FBQ0Y7QUFFQSxTQUFTLGNBQWMsUUFBZ0IsU0FBK0Q7QUFDcEcsTUFBSSxPQUFPLFlBQVksVUFBVTtBQUMvQixXQUFPLEdBQUcsTUFBTSxHQUFHLE9BQU87QUFBQSxFQUM1QjtBQUVBLFVBQVEsUUFBUSxNQUFNO0FBQ3RCLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K