@mnaoumov/obsidian-lib 10.8.0 → 10.10.0

package/dist/lib/esm/components/all-windows-event-component.mjs

@@ -2,8 +2,40 @@
 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 { getAllDomWindows } from "../workspace.mjs";
+import { isFunction } from "@mnaoumov/typescript-lib/type-guards";
+import { Component } from "obsidian";
+import {
+  getAllDomWindows,
+  getMainWindow
+} from "../workspace.mjs";
 import { ComponentEx } from "./component-ex.mjs";
 import { CallbackLayoutReadyComponent } from "./layout-ready-component.mjs";
 class AllWindowsEventComponent extends ComponentEx {
@@ -52,30 +84,71 @@ class AllWindowsEventComponent extends ComponentEx {
     });
   }
   /**
-   * Registers a handler for all windows (main window and all existing/future popup windows).
+   * Registers a handler once for each window, including popouts opened later.
    *
-   * @param allWindowsHandler - The handler called for each window (main + popups).
+   * @param allWindowsHandler - The handler. Its optional cleanup runs when the window closes or this component unloads.
    */
   registerAllWindowsHandler(allWindowsHandler) {
     this.ensureLoaded();
-    const mainWindow = activeWindow;
-    allWindowsHandler(mainWindow);
+    const componentsByWindow = /* @__PURE__ */ new Map();
+    this.register(() => {
+      componentsByWindow.clear();
+    });
+    const attach = (win) => {
+      if (componentsByWindow.has(win)) {
+        return;
+      }
+      const component = this.addChild(new Component());
+      componentsByWindow.set(win, component);
+      const cleanup = allWindowsHandler(win);
+      if (isFunction(cleanup)) {
+        component.register(cleanup);
+      }
+    };
+    this.registerEvent(this.app.workspace.on("window-close", (_workspaceWindow, win) => {
+      const component = componentsByWindow.get(win);
+      if (!component) {
+        return;
+      }
+      componentsByWindow.delete(win);
+      this.removeChild(component);
+    }));
+    attach(getMainWindow(this.app));
     this.addChild(
       new CallbackLayoutReadyComponent(this.app, () => {
-        for (const win of getAllDomWindows(this.app)) {
-          if (win === mainWindow) {
-            continue;
-          }
-          allWindowsHandler(win);
-        }
         this.registerEvent(this.app.workspace.on("window-open", (workspaceWindow) => {
-          allWindowsHandler(workspaceWindow.win);
+          attach(workspaceWindow.win);
         }));
+        for (const win of getAllDomWindows(this.app)) {
+          attach(win);
+        }
       })
     );
   }
 }
+function forEachWindow(params) {
+  const { app, callback, component } = params;
+  const allWindowsComponent = component.addChild(new AllWindowsEventComponent(app));
+  allWindowsComponent.registerAllWindowsHandler(callback);
+  return allWindowsComponent;
+}
+function registerBodyClass(params) {
+  const { app, className, component } = params;
+  return forEachWindow({
+    app,
+    callback(win) {
+      const { classList } = win.document.body;
+      classList.add(className);
+      return () => {
+        classList.remove(className);
+      };
+    },
+    component
+  });
+}
 export {
-  AllWindowsEventComponent
+  AllWindowsEventComponent,
+  forEachWindow,
+  registerBodyClass
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/all-windows-event-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Handles registering DOM events and handlers for all windows (main window and all existing/future popup windows) and their documents.\n */\n\nimport type { App } from 'obsidian';\n\nimport { isFunction } from '@mnaoumov/typescript-lib/type-guards';\nimport { Component } from 'obsidian';\n\nimport {\n  getAllDomWindows,\n  getMainWindow\n} from '../workspace.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * Parameters for {@link AllWindowsEventComponent.registerAllDocumentsDomEvent}.\n *\n * @typeParam DocumentEventType - The type of the event.\n */\nexport interface AllWindowsEventComponentRegisterAllDocumentsDomEventParams<DocumentEventType extends keyof DocumentEventMap> {\n  /**\n   * The callback to execute.\n   *\n   * @param $event - The event.\n   * @returns The result of the callback.\n   */\n  readonly callback: (this: HTMLElement, $event: DocumentEventMap[DocumentEventType]) => unknown;\n\n  /**\n   * The options for the event.\n   */\n  readonly options?: AddEventListenerOptions | boolean;\n\n  /**\n   * The type of the event.\n   */\n  readonly type: DocumentEventType;\n}\n\n/**\n * Parameters for {@link AllWindowsEventComponent.registerAllWindowsDomEvent}.\n *\n * @typeParam WindowEventType - The type of the event.\n */\nexport interface AllWindowsEventComponentRegisterAllWindowsDomEventParams<WindowEventType extends keyof WindowEventMap> {\n  /**\n   * The callback to execute.\n   *\n   * @param $event - The event.\n   * @returns The result of the callback.\n   */\n  readonly callback: (this: HTMLElement, $event: WindowEventMap[WindowEventType]) => unknown;\n\n  /**\n   * The options for the event.\n   */\n  readonly options?: AddEventListenerOptions | boolean;\n\n  /**\n   * The type of the event.\n   */\n  readonly type: WindowEventType;\n}\n\n/**\n * Parameters for {@link forEachWindow}.\n */\nexport interface ForEachWindowParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n  /**\n   * The handler, optionally returning cleanup for that window.\n   */\n  readonly callback: (win: Window) => unknown;\n  /**\n   * The component that owns the registration and its cleanup.\n   */\n  readonly component: Component;\n}\n\n/**\n * Parameters for {@link registerBodyClass}.\n */\nexport interface RegisterBodyClassParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n  /**\n   * One CSS class to add to each window's body. Use a plugin-specific name.\n   */\n  readonly className: string;\n  /**\n   * The component that owns the body class.\n   */\n  readonly component: Component;\n}\n\n/**\n * Handles registering DOM events and handlers for all windows (main window and all existing/future popup windows) and their documents.\n */\nexport class AllWindowsEventComponent extends ComponentEx {\n  /**\n   * Creates a new instance of the `AllWindowsEventComponent` class.\n   *\n   * @param app - The Obsidian app instance.\n   */\n  public constructor(protected readonly app: App) {\n    super();\n  }\n\n  /**\n   * Registers a DOM event for all documents (main window document and all existing/future popup window documents).\n   *\n   * @typeParam DocumentEventType - The type of the event.\n   * @param params - The parameters for registering the DOM event.\n   */\n  public registerAllDocumentsDomEvent<DocumentEventType extends keyof DocumentEventMap>(\n    params: AllWindowsEventComponentRegisterAllDocumentsDomEventParams<DocumentEventType>\n  ): void {\n    const {\n      callback,\n      options,\n      type\n    } = params;\n    this.ensureLoaded();\n\n    this.registerAllWindowsHandler((win) => {\n      this.registerDomEvent(win.document, type, callback, options);\n    });\n  }\n\n  /**\n   * Registers a DOM event for all windows (main window and all existing/future popup windows).\n   *\n   * @typeParam WindowEventType - The type of the event.\n   * @param params - The parameters for registering the DOM event.\n   */\n  public registerAllWindowsDomEvent<WindowEventType extends keyof WindowEventMap>(\n    params: AllWindowsEventComponentRegisterAllWindowsDomEventParams<WindowEventType>\n  ): void {\n    const {\n      callback,\n      options,\n      type\n    } = params;\n    this.ensureLoaded();\n\n    this.registerAllWindowsHandler((win) => {\n      this.registerDomEvent(win, type, callback, options);\n    });\n  }\n\n  /**\n   * Registers a handler once for each window, including popouts opened later.\n   *\n   * @param allWindowsHandler - The handler. Its optional cleanup runs when the window closes or this component unloads.\n   */\n  public registerAllWindowsHandler(allWindowsHandler: (win: Window) => unknown): void {\n    this.ensureLoaded();\n\n    const componentsByWindow = new Map<Window, Component>();\n    this.register(() => {\n      componentsByWindow.clear();\n    });\n\n    const attach = (win: Window): void => {\n      if (componentsByWindow.has(win)) {\n        return;\n      }\n\n      const component = this.addChild(new Component());\n      componentsByWindow.set(win, component);\n      const cleanup = allWindowsHandler(win);\n      if (isFunction(cleanup)) {\n        component.register(cleanup);\n      }\n    };\n\n    this.registerEvent(this.app.workspace.on('window-close', (_workspaceWindow, win) => {\n      const component = componentsByWindow.get(win);\n      if (!component) {\n        return;\n      }\n\n      componentsByWindow.delete(win);\n      this.removeChild(component);\n    }));\n\n    attach(getMainWindow(this.app));\n\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, () => {\n        this.registerEvent(this.app.workspace.on('window-open', (workspaceWindow) => {\n          attach(workspaceWindow.win);\n        }));\n\n        for (const win of getAllDomWindows(this.app)) {\n          attach(win);\n        }\n      })\n    );\n  }\n}\n\n/**\n * Applies a handler to the main window immediately and to existing and future popouts after layout ready.\n * Cleanup runs when each window closes or the owning component unloads.\n *\n * @param params - The registration parameters. The owner must be loaded.\n * @returns The child component; remove it from the owner to stop early.\n */\nexport function forEachWindow(params: ForEachWindowParams): AllWindowsEventComponent {\n  const { app, callback, component } = params;\n  const allWindowsComponent = component.addChild(new AllWindowsEventComponent(app));\n  allWindowsComponent.registerAllWindowsHandler(callback);\n  return allWindowsComponent;\n}\n\n/**\n * Adds a body class to the main window and every existing or future popout until the owner unloads.\n * Use a plugin-specific class owned exclusively by this registration.\n *\n * @param params - The registration parameters. The owner must be loaded.\n * @returns The child component; remove it from the owner to stop early.\n */\nexport function registerBodyClass(params: RegisterBodyClassParams): AllWindowsEventComponent {\n  const { app, className, component } = params;\n  return forEachWindow({\n    app,\n    callback(win) {\n      const { classList } = win.document.body;\n      classList.add(className);\n      return () => {\n        classList.remove(className);\n      };\n    },\n    component\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,kBAAkB;AAC3B,SAAS,iBAAiB;AAE1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mBAAmB;AAC5B,SAAS,oCAAoC;AA2FtC,MAAM,iCAAiC,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjD,YAA+B,KAAU;AAC9C,UAAM;AAD8B;AAAA,EAEtC;AAAA,EAFsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU/B,6BACL,QACM;AACN,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AACJ,SAAK,aAAa;AAElB,SAAK,0BAA0B,CAAC,QAAQ;AACtC,WAAK,iBAAiB,IAAI,UAAU,MAAM,UAAU,OAAO;AAAA,IAC7D,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,2BACL,QACM;AACN,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AACJ,SAAK,aAAa;AAElB,SAAK,0BAA0B,CAAC,QAAQ;AACtC,WAAK,iBAAiB,KAAK,MAAM,UAAU,OAAO;AAAA,IACpD,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,0BAA0B,mBAAmD;AAClF,SAAK,aAAa;AAElB,UAAM,qBAAqB,oBAAI,IAAuB;AACtD,SAAK,SAAS,MAAM;AAClB,yBAAmB,MAAM;AAAA,IAC3B,CAAC;AAED,UAAM,SAAS,CAAC,QAAsB;AACpC,UAAI,mBAAmB,IAAI,GAAG,GAAG;AAC/B;AAAA,MACF;AAEA,YAAM,YAAY,KAAK,SAAS,IAAI,UAAU,CAAC;AAC/C,yBAAmB,IAAI,KAAK,SAAS;AACrC,YAAM,UAAU,kBAAkB,GAAG;AACrC,UAAI,WAAW,OAAO,GAAG;AACvB,kBAAU,SAAS,OAAO;AAAA,MAC5B;AAAA,IACF;AAEA,SAAK,cAAc,KAAK,IAAI,UAAU,GAAG,gBAAgB,CAAC,kBAAkB,QAAQ;AAClF,YAAM,YAAY,mBAAmB,IAAI,GAAG;AAC5C,UAAI,CAAC,WAAW;AACd;AAAA,MACF;AAEA,yBAAmB,OAAO,GAAG;AAC7B,WAAK,YAAY,SAAS;AAAA,IAC5B,CAAC,CAAC;AAEF,WAAO,cAAc,KAAK,GAAG,CAAC;AAE9B,SAAK;AAAA,MACH,IAAI,6BAA6B,KAAK,KAAK,MAAM;AAC/C,aAAK,cAAc,KAAK,IAAI,UAAU,GAAG,eAAe,CAAC,oBAAoB;AAC3E,iBAAO,gBAAgB,GAAG;AAAA,QAC5B,CAAC,CAAC;AAEF,mBAAW,OAAO,iBAAiB,KAAK,GAAG,GAAG;AAC5C,iBAAO,GAAG;AAAA,QACZ;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AASO,SAAS,cAAc,QAAuD;AACnF,QAAM,EAAE,KAAK,UAAU,UAAU,IAAI;AACrC,QAAM,sBAAsB,UAAU,SAAS,IAAI,yBAAyB,GAAG,CAAC;AAChF,sBAAoB,0BAA0B,QAAQ;AACtD,SAAO;AACT;AASO,SAAS,kBAAkB,QAA2D;AAC3F,QAAM,EAAE,KAAK,WAAW,UAAU,IAAI;AACtC,SAAO,cAAc;AAAA,IACnB;AAAA,IACA,SAAS,KAAK;AACZ,YAAM,EAAE,UAAU,IAAI,IAAI,SAAS;AACnC,gBAAU,IAAI,SAAS;AACvB,aAAO,MAAM;AACX,kBAAU,OAAO,SAAS;AAAA,MAC5B;AAAA,IACF;AAAA,IACA;AAAA,EACF,CAAC;AACH;","names":[]}

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

@@ -131,4 +131,4 @@ export {
   around,
   hasPatchToken
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/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 { GenericFunction } from '@mnaoumov/typescript-lib/function';\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam $Object - The object to patch.\n */\nexport type Factories<$Object extends object> = Partial<FullFactories<$Object>>;\n\n/**\n * Keys of `Obj` whose value is callable — a method, or a function-like object such as a `Debouncer`. These are the members\n * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam $Object - The object whose keys are filtered.\n */\nexport type FunctionKeys<$Object extends object> = ConditionalKeys<$Object, GenericFunction | undefined> & keyof $Object;\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 — 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 $Object - The object whose keys are filtered.\n */\nexport type MethodKeys<$Object extends object> = MethodKeysMap<$Object>[FunctionKeys<$Object>];\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam $Object - The object to patch.\n * @typeParam FunctionName - The function name to patch.\n */\nexport interface MonkeyAroundComponentRegisterFunctionPatchParams<$Object extends object, FunctionName extends FunctionKeys<$Object>> {\n  /**\n   * The object to patch.\n   */\n  readonly $object: $Object;\n\n  /**\n   * The function name to patch.\n   */\n  readonly functionName: FunctionName;\n\n  /**\n   * When `true`, the patch uninstalls itself the first time the patched function is invoked (by\n   * unloading this component), restoring the original — so the interception happens exactly once.\n   * Intended for a component dedicated to this single patch. Existing callers that omit it are\n   * unaffected.\n   *\n   * @default `false`\n   */\n  readonly once?: boolean;\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  readonly patchHandler: (originalValue: $Object[FunctionName]) => $Object[FunctionName];\n}\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam $Object - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * The object to patch.\n   */\n  readonly $object: $Object;\n\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * When `true`, the patch uninstalls itself the first time the patched method is invoked, restoring\n   * the original — so the interception happens exactly once. Existing callers that omit it are\n   * unaffected.\n   *\n   * @default `false`\n   */\n  readonly once?: boolean;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFunction<$Object, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   *\n   * The token is recorded against the method this patch INSTALLS, so the next patch of the same method\n   * detects it via {@link hasPatchToken} on its own `originalMethod` and can defer to this one. The\n   * patch that installs a token therefore never sees its own token — only the patches stacked on top of\n   * it do. Use a `Symbol.for` token to make the detection work across independently bundled copies of\n   * this library.\n   *\n   * The token is dropped when this component unloads, so a later patch that had deferred takes over on\n   * its next call.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied, typically to keep the original method.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFunction<$Object, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (\n  params: PatchHandlerParams<$Object, MethodName>\n) => ReturnType<ExtractFunction<$Object, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFunction} callback.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * Invokes the original method with the original `this` and arguments.\n   *\n   * @returns Whatever the original method returns.\n   */\n  readonly fallback: () => ReturnType<ExtractFunction<$Object, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArguments: Parameters<ExtractFunction<$Object, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<$Object, 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<$Object, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: $Object;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * It returns nothing and is not handed the patched method: the method installed is always the one the patch builds, so\n * a post-patch handler cannot graft members onto it. A capability beyond the patched method's own signature belongs\n * on the plugin's published API instead.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (\n  params: PostPatchHandlerParams<$Object, MethodName>\n) => void;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFunction} callback.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<$Object, MethodName>;\n}\n\ntype ExtractFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = GenericFunction<Parameters<Extract<$Object[MethodName], GenericFunction>>, ReturnType<Extract<$Object[MethodName], GenericFunction>>>;\n\ntype FullFactories<$Object extends object> = {\n  [Key in keyof $Object]: (originalValue: $Object[Key]) => $Object[Key];\n};\n\ntype MethodKeysMap<$Object extends object> = {\n  [Key in FunctionKeys<$Object>]: [Exclude<keyof NonNullable<$Object[Key]>, keyof GenericFunction>] extends [never] ? Key : never;\n};\n\ntype OriginalFactories<$Object extends GenericObject> = Parameters<typeof originalAround<$Object>>[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 $Object - The object to patch.\n   * @typeParam FunctionName - The function name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerFunctionPatch<$Object extends object, const FunctionName extends FunctionKeys<$Object>>(\n    params: MonkeyAroundComponentRegisterFunctionPatchParams<$Object, FunctionName>\n  ): void {\n    this.ensureLoaded();\n\n    const factories: Factories<$Object> = {};\n    // eslint-disable-next-line unicorn/no-immediate-mutation -- A computed key in an object literal does not match `Partial<FullFactories<$Object>>` when the key type is generic; assigning after declaration keeps the target type known.\n    factories[params.functionName] = (originalValue: $Object[FunctionName]): $Object[FunctionName] => {\n      const patchedValue = params.patchHandler(originalValue);\n      if (!params.once) {\n        return patchedValue;\n      }\n\n      // A `once` patch unloads this component after the first invocation — running the registered\n      // uninstaller and restoring the original. `unloadComponent` is an arrow so it captures the\n      // component `this`; the nested `oncePatchedValue` must be a function to receive the call-time\n      // `this`. Own members (e.g. a `Debouncer`'s `cancel`/`run`) are copied onto it so function-like\n      // values keep working.\n      const unloadComponent = (): void => {\n        this.unload();\n      };\n      function oncePatchedValue(this: unknown, ...$arguments: unknown[]): unknown {\n        try {\n          return Reflect.apply(patchedValue, this, $arguments);\n        } finally {\n          unloadComponent();\n        }\n      }\n      return Object.assign(oncePatchedValue, patchedValue) as $Object[FunctionName];\n    };\n\n    this.registerPatch(params.$object, factories);\n  }\n\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam $Object - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<$Object extends object, const MethodName extends MethodKeys<$Object>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<$Object, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    type $Function = ExtractFunction<$Object, MethodName>;\n\n    this.registerFunctionPatch({\n      $object: params.$object,\n      functionName: params.methodName,\n      once: params.once ?? false,\n      patchHandler: (originalMethodRaw) => {\n        const originalMethod = originalMethodRaw as $Function;\n        params.postPatchHandler?.({ originalMethod });\n        return patchedMethod as $Object[MethodName];\n\n        function patchedMethod(this: $Object, ...originalArguments: Parameters<$Function>): ReturnType<$Function> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias, unicorn/no-this-assignment -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArguments);\n            },\n            originalArguments,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    });\n\n    if (!params.patchToken) {\n      return;\n    }\n\n    // The token marks the INSTALLED method, read back once the patch is in place.\n    // That is the identity the next patch of the same method receives as its `originalMethod`.\n    // `monkey-around` installs a wrapper of its own and exposes the value built above only via its prototype.\n    // Marking that value, or the method being wrapped as this once did, matches nothing the next patch sees.\n    // Dropping the token on unload lets a deferring later patch take over, since the guard is read per call.\n    const patchedMethod = params.$object[params.methodName] as GenericFunction;\n    const monkeyAroundPatches = getMonkeyAroundPatches();\n    monkeyAroundPatches.set(patchedMethod, params.patchToken);\n    this.register(() => {\n      monkeyAroundPatches.delete(patchedMethod);\n    });\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam $Object - The object to patch.\n   * @param $object - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<$Object extends object>($object: $Object, factories: Factories<$Object>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around($object, 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 $Object - The object to patch.\n * @param $object - 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<$Object extends object>($object: $Object, factories: Factories<$Object>): Uninstaller {\n  return originalAround($object as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * A token is carried by the method a {@link MonkeyAroundComponent#registerMethodPatch} call INSTALLED, so\n * the intended caller is a later patch of the same method, checking the `originalMethod` it wrapped in\n * order to defer to the patch already in place:\n *\n * ```ts\n * patchHandler: ({ fallback, originalMethod }) => {\n *   if (hasPatchToken(originalMethod, PATCH_TOKEN)) {\n *     return fallback();\n *   }\n *   ...\n * }\n * ```\n *\n * The check is made per call, so it stops reporting the earlier patch once that patch's component unloads.\n *\n * @param $function - 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($function: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get($function) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianLibState('monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,SAAS,UAAU,sBAAsB;AAEzC,SAAS,2BAA2B;AACpC,SAAS,mBAAmB;AA4MrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,sBACL,QACM;AACN,SAAK,aAAa;AAElB,UAAM,YAAgC,CAAC;AAEvC,cAAU,OAAO,YAAY,IAAI,CAAC,kBAAgE;AAChG,YAAM,eAAe,OAAO,aAAa,aAAa;AACtD,UAAI,CAAC,OAAO,MAAM;AAChB,eAAO;AAAA,MACT;AAOA,YAAM,kBAAkB,MAAY;AAClC,aAAK,OAAO;AAAA,MACd;AACA,eAAS,oBAAmC,YAAgC;AAC1E,YAAI;AACF,iBAAO,QAAQ,MAAM,cAAc,MAAM,UAAU;AAAA,QACrD,UAAE;AACA,0BAAgB;AAAA,QAClB;AAAA,MACF;AACA,aAAO,OAAO,OAAO,kBAAkB,YAAY;AAAA,IACrD;AAEA,SAAK,cAAc,OAAO,SAAS,SAAS;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBACL,QACM;AACN,SAAK,aAAa;AAIlB,SAAK,sBAAsB;AAAA,MACzB,SAAS,OAAO;AAAA,MAChB,cAAc,OAAO;AAAA,MACrB,MAAM,OAAO,QAAQ;AAAA,MACrB,cAAc,CAAC,sBAAsB;AACnC,cAAM,iBAAiB;AACvB,eAAO,mBAAmB,EAAE,eAAe,CAAC;AAC5C,eAAOA;AAEP,iBAASA,kBAAgC,mBAAiE;AAExG,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,iBAAiB;AAAA,YAC/D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAED,QAAI,CAAC,OAAO,YAAY;AACtB;AAAA,IACF;AAOA,UAAM,gBAAgB,OAAO,QAAQ,OAAO,UAAU;AACtD,UAAM,sBAAsB,uBAAuB;AACnD,wBAAoB,IAAI,eAAe,OAAO,UAAU;AACxD,SAAK,SAAS,MAAM;AAClB,0BAAoB,OAAO,aAAa;AAAA,IAC1C,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAsC,SAAkB,WAAqC;AAClG,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,SAAS,SAAS;AAC7C,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA+B,SAAkB,WAA4C;AAC3G,SAAO,eAAe,SAA0B,SAA6C;AAC/F;AAwBO,SAAS,cAAc,WAA4B,YAA6B;AACrF,SAAO,uBAAuB,EAAE,IAAI,SAAS,MAAM;AACrD;AAEA,SAAS,yBAA2D;AAClE,SAAO,oBAAoB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AAC5F;","names":["patchedMethod"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/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 { GenericFunction } from '@mnaoumov/typescript-lib/function';\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam $Object - The object to patch.\n */\nexport type Factories<$Object extends object> = Partial<FullFactories<$Object>>;\n\n/**\n * Keys of `Obj` whose value is callable — a method, or a function-like object such as a `Debouncer`. These are the members\n * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam $Object - The object whose keys are filtered.\n */\nexport type FunctionKeys<$Object extends object> = ConditionalKeys<$Object, GenericFunction | undefined> & keyof $Object;\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 — 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 $Object - The object whose keys are filtered.\n */\nexport type MethodKeys<$Object extends object> = MethodKeysMap<$Object>[FunctionKeys<$Object>];\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam $Object - The object to patch.\n * @typeParam FunctionName - The function name to patch.\n */\nexport interface MonkeyAroundComponentRegisterFunctionPatchParams<$Object extends object, FunctionName extends FunctionKeys<$Object>> {\n  /**\n   * The object to patch.\n   */\n  readonly $object: $Object;\n\n  /**\n   * The function name to patch.\n   */\n  readonly functionName: FunctionName;\n\n  /**\n   * When `true`, the patch uninstalls itself the first time the patched function is invoked (by\n   * unloading this component), restoring the original — so the interception happens exactly once.\n   * Intended for a component dedicated to this single patch. Existing callers that omit it are\n   * unaffected.\n   *\n   * @default `false`\n   */\n  readonly once?: boolean;\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  readonly patchHandler: (originalValue: $Object[FunctionName]) => $Object[FunctionName];\n}\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam $Object - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * The object to patch.\n   */\n  readonly $object: $Object;\n\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * When `true`, the patch uninstalls itself the first time the patched method is invoked, restoring\n   * the original — so the interception happens exactly once. Existing callers that omit it are\n   * unaffected.\n   *\n   * @default `false`\n   */\n  readonly once?: boolean;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFunction<$Object, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   *\n   * The token is recorded against the method this patch INSTALLS, so the next patch of the same method\n   * detects it via {@link hasPatchToken} on its own `originalMethod` and can defer to this one. The\n   * patch that installs a token therefore never sees its own token — only the patches stacked on top of\n   * it do. Use a `Symbol.for` token to make the detection work across independently bundled copies of\n   * this library.\n   *\n   * The token is dropped when this component unloads, so a later patch that had deferred takes over on\n   * its next call.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied, typically to keep the original method.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFunction<$Object, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (\n  params: PatchHandlerParams<$Object, MethodName>\n) => ReturnType<ExtractFunction<$Object, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFunction} callback.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * Invokes the original method with the original `this` and arguments.\n   *\n   * @returns Whatever the original method returns.\n   */\n  readonly fallback: () => ReturnType<ExtractFunction<$Object, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArguments: Parameters<ExtractFunction<$Object, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<$Object, 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<$Object, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: $Object;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * It returns nothing and is not handed the patched method: the method installed is always the one the patch builds, so\n * a post-patch handler cannot graft members onto it. A capability beyond the patched method's own signature belongs\n * on the plugin's published API instead.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (\n  params: PostPatchHandlerParams<$Object, MethodName>\n) => void;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFunction} callback.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<$Object, MethodName>;\n}\n\ntype ExtractFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = GenericFunction<Parameters<Extract<$Object[MethodName], GenericFunction>>, ReturnType<Extract<$Object[MethodName], GenericFunction>>>;\n\ntype FullFactories<$Object extends object> = {\n  [Key in keyof $Object]: (originalValue: $Object[Key]) => $Object[Key];\n};\n\ntype MethodKeysMap<$Object extends object> = {\n  [Key in FunctionKeys<$Object>]: [Exclude<keyof NonNullable<$Object[Key]>, keyof GenericFunction>] extends [never] ? Key : never;\n};\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 $Object - The object to patch.\n   * @typeParam FunctionName - The function name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerFunctionPatch<$Object extends object, const FunctionName extends FunctionKeys<$Object>>(\n    params: MonkeyAroundComponentRegisterFunctionPatchParams<$Object, FunctionName>\n  ): void {\n    this.ensureLoaded();\n\n    const factories: Factories<$Object> = {};\n    // eslint-disable-next-line unicorn/no-immediate-mutation -- A computed key in an object literal does not match `Partial<FullFactories<$Object>>` when the key type is generic; assigning after declaration keeps the target type known.\n    factories[params.functionName] = (originalValue: $Object[FunctionName]): $Object[FunctionName] => {\n      const patchedValue = params.patchHandler(originalValue);\n      if (!params.once) {\n        return patchedValue;\n      }\n\n      // A `once` patch unloads this component after the first invocation — running the registered\n      // uninstaller and restoring the original. `unloadComponent` is an arrow so it captures the\n      // component `this`; the nested `oncePatchedValue` must be a function to receive the call-time\n      // `this`. Own members (e.g. a `Debouncer`'s `cancel`/`run`) are copied onto it so function-like\n      // values keep working.\n      const unloadComponent = (): void => {\n        this.unload();\n      };\n      function oncePatchedValue(this: unknown, ...$arguments: unknown[]): unknown {\n        try {\n          return Reflect.apply(patchedValue, this, $arguments);\n        } finally {\n          unloadComponent();\n        }\n      }\n      return Object.assign(oncePatchedValue, patchedValue) as $Object[FunctionName];\n    };\n\n    this.registerPatch(params.$object, factories);\n  }\n\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam $Object - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<$Object extends object, const MethodName extends MethodKeys<$Object>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<$Object, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    this.registerFunctionPatch({\n      $object: params.$object,\n      functionName: params.methodName,\n      once: params.once ?? false,\n      patchHandler: (originalMethodRaw) => {\n        type $Function = ExtractFunction<$Object, MethodName>;\n        const originalMethod = originalMethodRaw as $Function;\n        params.postPatchHandler?.({ originalMethod });\n        return patchedMethod as $Object[MethodName];\n\n        function patchedMethod(this: $Object, ...originalArguments: Parameters<$Function>): ReturnType<$Function> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias, unicorn/no-this-assignment -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArguments);\n            },\n            originalArguments,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    });\n\n    if (!params.patchToken) {\n      return;\n    }\n\n    // The token marks the INSTALLED method, read back once the patch is in place.\n    // That is the identity the next patch of the same method receives as its `originalMethod`.\n    // `monkey-around` installs a wrapper of its own and exposes the value built above only via its prototype.\n    // Marking that value, or the method being wrapped as this once did, matches nothing the next patch sees.\n    // Dropping the token on unload lets a deferring later patch take over, since the guard is read per call.\n    const patchedMethod = params.$object[params.methodName] as GenericFunction;\n    const monkeyAroundPatches = getMonkeyAroundPatches();\n    monkeyAroundPatches.set(patchedMethod, params.patchToken);\n    this.register(() => {\n      monkeyAroundPatches.delete(patchedMethod);\n    });\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam $Object - The object to patch.\n   * @param $object - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<$Object extends object>($object: $Object, factories: Factories<$Object>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around($object, 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 $Object - The object to patch.\n * @param $object - 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<$Object extends object>($object: $Object, factories: Factories<$Object>): Uninstaller {\n  type OriginalFactories<$Target extends GenericObject> = Parameters<typeof originalAround<$Target>>[1];\n  return originalAround($object as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * A token is carried by the method a {@link MonkeyAroundComponent#registerMethodPatch} call INSTALLED, so\n * the intended caller is a later patch of the same method, checking the `originalMethod` it wrapped in\n * order to defer to the patch already in place:\n *\n * ```ts\n * patchHandler: ({ fallback, originalMethod }) => {\n *   if (hasPatchToken(originalMethod, PATCH_TOKEN)) {\n *     return fallback();\n *   }\n *   ...\n * }\n * ```\n *\n * The check is made per call, so it stops reporting the earlier patch once that patch's component unloads.\n *\n * @param $function - 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($function: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get($function) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianLibState('monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,SAAS,UAAU,sBAAsB;AAEzC,SAAS,2BAA2B;AACpC,SAAS,mBAAmB;AA0MrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,sBACL,QACM;AACN,SAAK,aAAa;AAElB,UAAM,YAAgC,CAAC;AAEvC,cAAU,OAAO,YAAY,IAAI,CAAC,kBAAgE;AAChG,YAAM,eAAe,OAAO,aAAa,aAAa;AACtD,UAAI,CAAC,OAAO,MAAM;AAChB,eAAO;AAAA,MACT;AAOA,YAAM,kBAAkB,MAAY;AAClC,aAAK,OAAO;AAAA,MACd;AACA,eAAS,oBAAmC,YAAgC;AAC1E,YAAI;AACF,iBAAO,QAAQ,MAAM,cAAc,MAAM,UAAU;AAAA,QACrD,UAAE;AACA,0BAAgB;AAAA,QAClB;AAAA,MACF;AACA,aAAO,OAAO,OAAO,kBAAkB,YAAY;AAAA,IACrD;AAEA,SAAK,cAAc,OAAO,SAAS,SAAS;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBACL,QACM;AACN,SAAK,aAAa;AAElB,SAAK,sBAAsB;AAAA,MACzB,SAAS,OAAO;AAAA,MAChB,cAAc,OAAO;AAAA,MACrB,MAAM,OAAO,QAAQ;AAAA,MACrB,cAAc,CAAC,sBAAsB;AAEnC,cAAM,iBAAiB;AACvB,eAAO,mBAAmB,EAAE,eAAe,CAAC;AAC5C,eAAOA;AAEP,iBAASA,kBAAgC,mBAAiE;AAExG,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,iBAAiB;AAAA,YAC/D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAED,QAAI,CAAC,OAAO,YAAY;AACtB;AAAA,IACF;AAOA,UAAM,gBAAgB,OAAO,QAAQ,OAAO,UAAU;AACtD,UAAM,sBAAsB,uBAAuB;AACnD,wBAAoB,IAAI,eAAe,OAAO,UAAU;AACxD,SAAK,SAAS,MAAM;AAClB,0BAAoB,OAAO,aAAa;AAAA,IAC1C,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAsC,SAAkB,WAAqC;AAClG,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,SAAS,SAAS;AAC7C,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA+B,SAAkB,WAA4C;AAE3G,SAAO,eAAe,SAA0B,SAA6C;AAC/F;AAwBO,SAAS,cAAc,WAA4B,YAA6B;AACrF,SAAO,uBAAuB,EAAE,IAAI,SAAS,MAAM;AACrD;AAEA,SAAS,yBAA2D;AAClE,SAAO,oBAAoB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AAC5F;","names":["patchedMethod"]}