obsidian-dev-utils 55.4.0 → 56.0.0

package/dist/lib/esm/obsidian/backlink.mjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   if (globalThis.process) {
     return;
   }
@@ -16,6 +17,7 @@ if you want to view the source, please visit the github repository of this plugi
     env: {},
     platform: 'android'
   };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   globalThis.process = browserProcess;
 })();
 
@@ -100,4 +102,4 @@ export {
   renderDelayedBacklinks,
   renderDelayedBacklinksForFolder
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2JhY2tsaW5rLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUHJvdmlkZXMgdXRpbGl0eSBmdW5jdGlvbnMgZm9yIHdvcmtpbmcgd2l0aCBiYWNrbGlua3MuXG4gKi9cblxuLyogdjggaWdub3JlIHN0YXJ0IC0tIERlZXBseSBjb3VwbGVkIHRvIE9ic2lkaWFuIHJ1bnRpbWU7IHJlcXVpcmVzIHJ1bm5pbmcgdmF1bHQgZm9yIG1lYW5pbmdmdWwgdGVzdGluZy4gKi9cblxuaW1wb3J0IHR5cGUgeyBURmlsZSB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHR5cGUge1xuICBEYXRhdmlld0lubGluZUFwaSxcbiAgTGlua1xufSBmcm9tICcuL2RhdGF2aWV3LnRzJztcbmltcG9ydCB0eXBlIHtcbiAgUGF0aE9yQWJzdHJhY3RGaWxlLFxuICBQYXRoT3JGaWxlXG59IGZyb20gJy4vZmlsZS1zeXN0ZW0udHMnO1xuXG5pbXBvcnQgeyBlbnN1cmVOb25OdWxsYWJsZSB9IGZyb20gJy4uL3R5cGUtZ3VhcmRzLnRzJztcbmltcG9ydCB7IHJlbmRlckNhbGxvdXQgfSBmcm9tICcuL2NhbGxvdXQudHMnO1xuaW1wb3J0IHsgZml4VGl0bGUgfSBmcm9tICcuL2RhdGF2aWV3LWxpbmsudHMnO1xuaW1wb3J0IHsgcmVuZGVyUGFnaW5hdGVkVGFibGUgfSBmcm9tICcuL2RhdGF2aWV3LnRzJztcbmltcG9ydCB7XG4gIGdldEFic3RyYWN0RmlsZU9yTnVsbCxcbiAgZ2V0TWFya2Rvd25GaWxlcyxcbiAgaXNGaWxlLFxuICBpc0ZvbGRlclxufSBmcm9tICcuL2ZpbGUtc3lzdGVtLnRzJztcbmltcG9ydCB7IGdlbmVyYXRlTWFya2Rvd25MaW5rIH0gZnJvbSAnLi9saW5rLnRzJztcbmltcG9ydCB7IGdldEJhY2tsaW5rc0ZvckZpbGVTYWZlIH0gZnJvbSAnLi9tZXRhZGF0YS1jYWNoZS50cyc7XG5cbi8qKlxuICogT3B0aW9ucyBmb3Ige0BsaW5rIHJlbmRlckRlbGF5ZWRCYWNrbGlua3NGb3JGb2xkZXJ9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFJlbmRlckRlbGF5ZWRCYWNrbGlua3NGb3JGb2xkZXJQYXJhbXMge1xuICAvKipcbiAgICogQSB7QGxpbmsgRGF0YXZpZXdJbmxpbmVBcGl9IGluc3RhbmNlLlxuICAgKi9cbiAgcmVhZG9ubHkgZHY6IERhdGF2aWV3SW5saW5lQXBpO1xuXG4gIC8qKlxuICAgKiBBIGZvbGRlciBwYXRoLiBJZiBub3QgcHJvdmlkZWQsIHRoZSBjdXJyZW50IGZpbGUncyBmb2xkZXIgd2lsbCBiZSB1c2VkLlxuICAgKi9cbiAgcmVhZG9ubHkgZm9sZGVyPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBBIHRpdGxlIGZvciB0aGUgcmVuZGVyZWQgYmFja2xpbmtzLiBEZWZhdWx0cyB0byBcIkZvbGRlciBCYWNrbGlua3NcIi5cbiAgICovXG4gIHJlYWRvbmx5IHRpdGxlPzogc3RyaW5nO1xufVxuXG4vKipcbiAqIE9wdGlvbnMgZm9yIHtAbGluayByZW5kZXJEZWxheWVkQmFja2xpbmtzfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZW5kZXJEZWxheWVkQmFja2xpbmtzUGFyYW1zIHtcbiAgLyoqXG4gICAqIEEge0BsaW5rIERhdGF2aWV3SW5saW5lQXBpfSBpbnN0YW5jZS5cbiAgICovXG4gIHJlYWRvbmx5IGR2OiBEYXRhdmlld0lubGluZUFwaTtcblxuICAvKipcbiAgICogQW4gYXJyYXkgb2YgUGF0aE9yRmlsZS5cbiAgICovXG4gIHJlYWRvbmx5IGZpbGVzOiBQYXRoT3JGaWxlW107XG5cbiAgLyoqXG4gICAqIEEgdGl0bGUgZm9yIHRoZSByZW5kZXJlZCBiYWNrbGlua3MuIERlZmF1bHRzIHRvIFwiQmFja2xpbmtzXCIuXG4gICAqL1xuICByZWFkb25seSB0aXRsZT86IHN0cmluZztcbn1cblxuLyoqXG4gKiBSZW5kZXJzIGEgYmFja2xpbmtzIHRhYmxlIHVzaW5nIHRoZSBwcm92aWRlZCBEYXRhdmlld0lubGluZUFwaSBhbmQgb3B0aW9uYWwgYXJyYXkgb2YgUGF0aE9yQWJzdHJhY3RGaWxlLlxuICpcbiAqIEBwYXJhbSBkdiAtIFRoZSBEYXRhdmlld0lubGluZUFwaSBpbnN0YW5jZS5cbiAqIEBwYXJhbSBwYXRoT3JGaWxlcyAtIEFuIG9wdGlvbmFsIGFycmF5IG9mIFBhdGhPckFic3RyYWN0RmlsZS5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgYmFja2xpbmtzIHRhYmxlIGhhcyBiZWVuIHJlbmRlcmVkLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcmVuZGVyQmFja2xpbmtzVGFibGUoZHY6IERhdGF2aWV3SW5saW5lQXBpLCBwYXRoT3JGaWxlcz86IFBhdGhPckFic3RyYWN0RmlsZVtdKTogUHJvbWlzZTx2b2lkPiB7XG4gIHBhdGhPckZpbGVzID8/PSBbXTtcbiAgY29uc3QgZmlsZXM6IFRGaWxlW10gPSBwYXRoT3JGaWxlcy5mbGF0TWFwKChhYnN0cmFjdEZpbGVPclBhdGgpID0+IHtcbiAgICBjb25zdCBhYnN0cmFjdEZpbGUgPSBnZXRBYnN0cmFjdEZpbGVPck51bGwoZHYuYXBwLCBhYnN0cmFjdEZpbGVPclBhdGgpO1xuICAgIGlmICghYWJzdHJhY3RGaWxlKSB7XG4gICAgICByZXR1cm4gW107XG4gICAgfVxuXG4gICAgaWYgKGlzRmlsZShhYnN0cmFjdEZpbGUpKSB7XG4gICAgICByZXR1cm4gW2Fic3RyYWN0RmlsZV07XG4gICAgfVxuXG4gICAgaWYgKCFpc0ZvbGRlcihhYnN0cmFjdEZpbGUpKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0V4cGVjdGVkIGEgZm9sZGVyJyk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGdldE1hcmtkb3duRmlsZXMoZHYuYXBwLCBhYnN0cmFjdEZpbGUsIHRydWUpO1xuICB9KTtcblxuICBjb25zdCBiYWNrbGlua1Jvd3M6IFtMaW5rLCBzdHJpbmdbXV1bXSA9IFtdO1xuXG4gIGZvciAoY29uc3QgZmlsZSBvZiBmaWxlcykge1xuICAgIGNvbnN0IGxpbmsgPSBmaXhUaXRsZShkdiwgZmlsZS5wYXRoKTtcbiAgICBjb25zdCBiYWNrbGlua3MgPSBhd2FpdCBnZXRCYWNrbGlua3NGb3JGaWxlU2FmZShkdi5hcHAsIGZpbGUpO1xuICAgIGNvbnN0IGJhY2tsaW5rTGlua3MgPSBiYWNrbGlua3Mua2V5cygpLm1hcCgoYmFja0xpbmtQYXRoKSA9PiB7XG4gICAgICBjb25zdCBtYXJrZG93bkxpbmsgPSBnZW5lcmF0ZU1hcmtkb3duTGluayh7XG4gICAgICAgIGFwcDogZHYuYXBwLFxuICAgICAgICBzb3VyY2VQYXRoT3JGaWxlOiBkdi5jdXJyZW50KCkuZmlsZS5wYXRoLFxuICAgICAgICB0YXJnZXRQYXRoT3JGaWxlOiBlbnN1cmVOb25OdWxsYWJsZShkdi5hcHAubWV0YWRhdGFDYWNoZS5nZXRGaXJzdExpbmtwYXRoRGVzdChiYWNrTGlua1BhdGgsIGZpbGUucGF0aCksICdMaW5rIG5vdCBmb3VuZCcpXG4gICAgICB9KTtcblxuICAgICAgcmV0dXJuIGAke21hcmtkb3duTGlua30gKCR7YmFja0xpbmtQYXRofSlgO1xuICAgIH0pO1xuICAgIGlmIChiYWNrbGlua0xpbmtzLmxlbmd0aCkge1xuICAgICAgYmFja2xpbmtSb3dzLnB1c2goW2xpbmssIGJhY2tsaW5rTGlua3NdKTtcbiAgICB9XG4gIH1cblxuICBhd2FpdCByZW5kZXJQYWdpbmF0ZWRUYWJsZSh7XG4gICAgZHYsXG4gICAgaGVhZGVyczogWydOb3RlJywgJ0JhY2tsaW5rcyddLFxuICAgIHJvd3M6IGJhY2tsaW5rUm93c1xuICB9KTtcbn1cblxuLyoqXG4gKiBSZW5kZXJzIGRlbGF5ZWQgYmFja2xpbmtzLlxuICpcbiAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgcGFyYW1ldGVycyBmb3IgcmVuZGVyaW5nIGRlbGF5ZWQgYmFja2xpbmtzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVuZGVyRGVsYXllZEJhY2tsaW5rcyhwYXJhbXM6IFJlbmRlckRlbGF5ZWRCYWNrbGlua3NQYXJhbXMpOiB2b2lkIHtcbiAgY29uc3Qge1xuICAgIGR2LFxuICAgIGZpbGVzLFxuICAgIHRpdGxlID0gJ0JhY2tsaW5rcydcbiAgfSA9IHBhcmFtcztcbiAgcmVuZGVyQ2FsbG91dCh7XG4gICAgYXN5bmMgY29udGVudFByb3ZpZGVyKCkge1xuICAgICAgYXdhaXQgcmVuZGVyQmFja2xpbmtzVGFibGUoZHYsIGZpbGVzKTtcbiAgICB9LFxuICAgIGR2LFxuICAgIGhlYWRlcjogdGl0bGVcbiAgfSk7XG59XG5cbi8qKlxuICogUmVuZGVycyBkZWxheWVkIGJhY2tsaW5rcyBmb3IgYSBzcGVjaWZpYyBmb2xkZXIuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBwYXJhbWV0ZXJzIGZvciByZW5kZXJpbmcgZGVsYXllZCBiYWNrbGlua3MuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZW5kZXJEZWxheWVkQmFja2xpbmtzRm9yRm9sZGVyKHBhcmFtczogUmVuZGVyRGVsYXllZEJhY2tsaW5rc0ZvckZvbGRlclBhcmFtcyk6IHZvaWQge1xuICBjb25zdCB7XG4gICAgZHYsXG4gICAgZm9sZGVyLFxuICAgIHRpdGxlID0gJ0ZvbGRlciBCYWNrbGlua3MnXG4gIH0gPSBwYXJhbXM7XG4gIGNvbnN0IGZvbGRlcjIgPSBmb2xkZXIgPz8gZHYuY3VycmVudCgpLmZpbGUuZm9sZGVyO1xuICByZW5kZXJEZWxheWVkQmFja2xpbmtzKHtcbiAgICBkdixcbiAgICBmaWxlczogZ2V0TWFya2Rvd25GaWxlcyhkdi5hcHAsIGZvbGRlcjIsIHRydWUpLFxuICAgIHRpdGxlXG4gIH0pO1xufVxuXG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFtQkEsU0FBUyx5QkFBeUI7QUFDbEMsU0FBUyxxQkFBcUI7QUFDOUIsU0FBUyxnQkFBZ0I7QUFDekIsU0FBUyw0QkFBNEI7QUFDckM7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsT0FDSztBQUNQLFNBQVMsNEJBQTRCO0FBQ3JDLFNBQVMsK0JBQStCO0FBaUR4QyxlQUFzQixxQkFBcUIsSUFBdUIsYUFBbUQ7QUFDbkgsa0JBQWdCLENBQUM7QUFDakIsUUFBTSxRQUFpQixZQUFZLFFBQVEsQ0FBQyx1QkFBdUI7QUFDakUsVUFBTSxlQUFlLHNCQUFzQixHQUFHLEtBQUssa0JBQWtCO0FBQ3JFLFFBQUksQ0FBQyxjQUFjO0FBQ2pCLGFBQU8sQ0FBQztBQUFBLElBQ1Y7QUFFQSxRQUFJLE9BQU8sWUFBWSxHQUFHO0FBQ3hCLGFBQU8sQ0FBQyxZQUFZO0FBQUEsSUFDdEI7QUFFQSxRQUFJLENBQUMsU0FBUyxZQUFZLEdBQUc7QUFDM0IsWUFBTSxJQUFJLE1BQU0sbUJBQW1CO0FBQUEsSUFDckM7QUFFQSxXQUFPLGlCQUFpQixHQUFHLEtBQUssY0FBYyxJQUFJO0FBQUEsRUFDcEQsQ0FBQztBQUVELFFBQU0sZUFBbUMsQ0FBQztBQUUxQyxhQUFXLFFBQVEsT0FBTztBQUN4QixVQUFNLE9BQU8sU0FBUyxJQUFJLEtBQUssSUFBSTtBQUNuQyxVQUFNLFlBQVksTUFBTSx3QkFBd0IsR0FBRyxLQUFLLElBQUk7QUFDNUQsVUFBTSxnQkFBZ0IsVUFBVSxLQUFLLEVBQUUsSUFBSSxDQUFDLGlCQUFpQjtBQUMzRCxZQUFNLGVBQWUscUJBQXFCO0FBQUEsUUFDeEMsS0FBSyxHQUFHO0FBQUEsUUFDUixrQkFBa0IsR0FBRyxRQUFRLEVBQUUsS0FBSztBQUFBLFFBQ3BDLGtCQUFrQixrQkFBa0IsR0FBRyxJQUFJLGNBQWMscUJBQXFCLGNBQWMsS0FBSyxJQUFJLEdBQUcsZ0JBQWdCO0FBQUEsTUFDMUgsQ0FBQztBQUVELGFBQU8sR0FBRyxZQUFZLEtBQUssWUFBWTtBQUFBLElBQ3pDLENBQUM7QUFDRCxRQUFJLGNBQWMsUUFBUTtBQUN4QixtQkFBYSxLQUFLLENBQUMsTUFBTSxhQUFhLENBQUM7QUFBQSxJQUN6QztBQUFBLEVBQ0Y7QUFFQSxRQUFNLHFCQUFxQjtBQUFBLElBQ3pCO0FBQUEsSUFDQSxTQUFTLENBQUMsUUFBUSxXQUFXO0FBQUEsSUFDN0IsTUFBTTtBQUFBLEVBQ1IsQ0FBQztBQUNIO0FBT08sU0FBUyx1QkFBdUIsUUFBNEM7QUFDakYsUUFBTTtBQUFBLElBQ0o7QUFBQSxJQUNBO0FBQUEsSUFDQSxRQUFRO0FBQUEsRUFDVixJQUFJO0FBQ0osZ0JBQWM7QUFBQSxJQUNaLE1BQU0sa0JBQWtCO0FBQ3RCLFlBQU0scUJBQXFCLElBQUksS0FBSztBQUFBLElBQ3RDO0FBQUEsSUFDQTtBQUFBLElBQ0EsUUFBUTtBQUFBLEVBQ1YsQ0FBQztBQUNIO0FBT08sU0FBUyxnQ0FBZ0MsUUFBcUQ7QUFDbkcsUUFBTTtBQUFBLElBQ0o7QUFBQSxJQUNBO0FBQUEsSUFDQSxRQUFRO0FBQUEsRUFDVixJQUFJO0FBQ0osUUFBTSxVQUFVLFVBQVUsR0FBRyxRQUFRLEVBQUUsS0FBSztBQUM1Qyx5QkFBdUI7QUFBQSxJQUNyQjtBQUFBLElBQ0EsT0FBTyxpQkFBaUIsR0FBRyxLQUFLLFNBQVMsSUFBSTtBQUFBLElBQzdDO0FBQUEsRUFDRixDQUFDO0FBQ0g7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/obsidian/callout.mjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   if (globalThis.process) {
     return;
   }
@@ -16,6 +17,7 @@ if you want to view the source, please visit the github repository of this plugi
     env: {},
     platform: 'android'
   };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   globalThis.process = browserProcess;
 })();
 
@@ -92,4 +94,4 @@ export {
   renderCallout,
   wrapForCallout
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/code-block-markdown-information.mjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   if (globalThis.process) {
     return;
   }
@@ -16,6 +17,7 @@ if you want to view the source, please visit the github repository of this plugi
     env: {},
     platform: 'android'
   };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   globalThis.process = browserProcess;
 })();
 

package/dist/lib/esm/obsidian/command-handlers/abstract-file-command-handler.d.mts

@@ -0,0 +1,178 @@
+/**
+ * @file
+ *
+ * Command handler for abstract file commands with file/files menu integration.
+ */
+import type { IconName, TAbstractFile, WorkspaceLeaf } from 'obsidian';
+import type { CommandHandlerParams, CommandHandlerRegistrationContext } from './command-handler.mjs';
+import { GlobalCommandHandler } from './global-command-handler.mjs';
+/**
+ * Parameters for creating an abstract file command handler.
+ */
+export interface AbstractFileCommandHandlerParams extends CommandHandlerParams {
+    /**
+     * The item name to use in the single-file menu.
+     */
+    readonly fileMenuItemName?: string | undefined;
+    /**
+     * The section to use in the single-file menu.
+     */
+    readonly fileMenuSection?: string | undefined;
+    /**
+     * The icon to use in the single-file menu submenu.
+     */
+    readonly fileMenuSubmenuIcon?: IconName | undefined;
+    /**
+     * The item name to use in the multi-file menu.
+     */
+    readonly filesMenuItemName?: string | undefined;
+    /**
+     * The section to use in the multi-file menu.
+     */
+    readonly filesMenuSection?: string | undefined;
+    /**
+     * The icon to use in the multi-file menu submenu.
+     */
+    readonly filesMenuSubmenuIcon?: IconName | undefined;
+    /**
+     * Whether to add the command to a submenu.
+     */
+    readonly shouldAddCommandToSubmenu?: boolean | undefined;
+}
+/**
+ * Command handler for abstract file commands.
+ *
+ * Handles both single-file and multi-file context menus.
+ * Subclasses override {@link canExecuteAbstractFile} and {@link executeAbstractFile}.
+ */
+export declare abstract class AbstractFileCommandHandler extends GlobalCommandHandler {
+    /**
+     * Gets the item name to use in the single-file menu.
+     *
+     * @returns The item name, or `undefined` to use the command name.
+     */
+    protected get fileMenuItemName(): string | undefined;
+    /**
+     * Gets the section to use in the single-file menu.
+     *
+     * @returns The section name, or `undefined` to use the plugin name.
+     */
+    protected get fileMenuSection(): string | undefined;
+    /**
+     * Gets the icon to use in the single-file menu submenu.
+     *
+     * @returns The icon, or `undefined` for no icon.
+     */
+    protected get fileMenuSubmenuIcon(): IconName | undefined;
+    /**
+     * Gets the item name to use in the multi-file menu.
+     *
+     * @returns The item name, or `undefined` to fall back to single-file item name.
+     */
+    protected get filesMenuItemName(): string | undefined;
+    /**
+     * Gets the section to use in the multi-file menu.
+     *
+     * @returns The section name, or `undefined` to fall back to single-file section.
+     */
+    protected get filesMenuSection(): string | undefined;
+    /**
+     * Gets the icon to use in the multi-file menu submenu.
+     *
+     * @returns The icon, or `undefined` to fall back to single-file submenu icon.
+     */
+    protected get filesMenuSubmenuIcon(): IconName | undefined;
+    /**
+     * Gets whether to add the command to a submenu.
+     *
+     * @returns Whether to add to a submenu.
+     */
+    protected get shouldAddCommandToSubmenu(): boolean | undefined;
+    private readonly _fileMenuItemName?;
+    private readonly _fileMenuSection?;
+    private readonly _fileMenuSubmenuIcon?;
+    private readonly _filesMenuItemName?;
+    private readonly _filesMenuSection?;
+    private readonly _filesMenuSubmenuIcon?;
+    private readonly _shouldAddCommandToSubmenu?;
+    private activeFileProvider?;
+    /**
+     * Creates a new abstract file command handler.
+     *
+     * @param params - The parameters for the abstract file command handler.
+     */
+    constructor(params: AbstractFileCommandHandlerParams);
+    /**
+     * Registers file-menu and files-menu event handlers.
+     *
+     * @param context - The registration context.
+     */
+    onRegistered(context: CommandHandlerRegistrationContext): Promise<void>;
+    /**
+     * Checks whether the command can execute from the command palette.
+     * Uses the active file as the target.
+     *
+     * @returns Whether the command can execute.
+     */
+    protected canExecute(): boolean;
+    /**
+     * Checks whether the command can execute for a single abstract file.
+     *
+     * @param _abstractFile - The file or folder.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteAbstractFile(_abstractFile: TAbstractFile): boolean;
+    /**
+     * Checks whether the command can execute for multiple abstract files.
+     * Default implementation checks each file individually.
+     *
+     * @param abstractFiles - The files or folders.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean;
+    /**
+     * Executes the command from the command palette using the active file.
+     */
+    protected execute(): Promise<void>;
+    /**
+     * Executes the command for a single abstract file.
+     *
+     * @param abstractFile - The file or folder.
+     */
+    protected abstract executeAbstractFile(abstractFile: TAbstractFile): Promise<void>;
+    /**
+     * Executes the command for multiple abstract files.
+     * Default implementation executes sequentially.
+     *
+     * @param abstractFiles - The files or folders.
+     */
+    protected executeAbstractFiles(abstractFiles: TAbstractFile[]): Promise<void>;
+    /**
+     * Checks whether the command should appear in the single-file context menu.
+     *
+     * @param _abstractFile - The file or folder.
+     * @param _source - The source of the event.
+     * @param _leaf - The workspace leaf, if available.
+     * @returns Whether to add to the file menu.
+     */
+    protected shouldAddToAbstractFileMenu(_abstractFile: TAbstractFile, _source: string, _leaf?: WorkspaceLeaf): boolean;
+    /**
+     * Checks whether the command should appear in the multi-file context menu.
+     * Default implementation checks each file individually.
+     *
+     * @param abstractFiles - The files or folders.
+     * @param source - The source of the event.
+     * @param leaf - The workspace leaf, if available.
+     * @returns Whether to add to the files menu.
+     */
+    protected shouldAddToAbstractFilesMenu(abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): boolean;
+    /**
+     * Checks whether the command should appear in the command palette.
+     *
+     * @returns Whether to add to the command palette.
+     */
+    protected shouldAddToCommandPalette(): boolean;
+    private getActiveFile;
+    private handleAbstractFileMenu;
+    private handleAbstractFilesMenu;
+}

package/dist/lib/esm/obsidian/command-handlers/abstract-file-command-handler.mjs

@@ -0,0 +1,247 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { invokeAsyncSafely } from "../../async.mjs";
+import { GlobalCommandHandler } from "./global-command-handler.mjs";
+class AbstractFileCommandHandler extends GlobalCommandHandler {
+  /**
+   * Gets the item name to use in the single-file menu.
+   *
+   * @returns The item name, or `undefined` to use the command name.
+   */
+  get fileMenuItemName() {
+    return this._fileMenuItemName;
+  }
+  /**
+   * Gets the section to use in the single-file menu.
+   *
+   * @returns The section name, or `undefined` to use the plugin name.
+   */
+  get fileMenuSection() {
+    return this._fileMenuSection;
+  }
+  /**
+   * Gets the icon to use in the single-file menu submenu.
+   *
+   * @returns The icon, or `undefined` for no icon.
+   */
+  get fileMenuSubmenuIcon() {
+    return this._fileMenuSubmenuIcon;
+  }
+  /**
+   * Gets the item name to use in the multi-file menu.
+   *
+   * @returns The item name, or `undefined` to fall back to single-file item name.
+   */
+  get filesMenuItemName() {
+    return this._filesMenuItemName;
+  }
+  /**
+   * Gets the section to use in the multi-file menu.
+   *
+   * @returns The section name, or `undefined` to fall back to single-file section.
+   */
+  get filesMenuSection() {
+    return this._filesMenuSection;
+  }
+  /**
+   * Gets the icon to use in the multi-file menu submenu.
+   *
+   * @returns The icon, or `undefined` to fall back to single-file submenu icon.
+   */
+  get filesMenuSubmenuIcon() {
+    return this._filesMenuSubmenuIcon;
+  }
+  /**
+   * Gets whether to add the command to a submenu.
+   *
+   * @returns Whether to add to a submenu.
+   */
+  get shouldAddCommandToSubmenu() {
+    return this._shouldAddCommandToSubmenu;
+  }
+  _fileMenuItemName;
+  _fileMenuSection;
+  _fileMenuSubmenuIcon;
+  _filesMenuItemName;
+  _filesMenuSection;
+  _filesMenuSubmenuIcon;
+  _shouldAddCommandToSubmenu;
+  activeFileProvider;
+  /**
+   * Creates a new abstract file command handler.
+   *
+   * @param params - The parameters for the abstract file command handler.
+   */
+  constructor(params) {
+    super(params);
+    this._fileMenuItemName = params.fileMenuItemName;
+    this._fileMenuSection = params.fileMenuSection;
+    this._fileMenuSubmenuIcon = params.fileMenuSubmenuIcon;
+    this._filesMenuItemName = params.filesMenuItemName;
+    this._filesMenuSection = params.filesMenuSection;
+    this._filesMenuSubmenuIcon = params.filesMenuSubmenuIcon;
+    this._shouldAddCommandToSubmenu = params.shouldAddCommandToSubmenu;
+  }
+  /**
+   * Registers file-menu and files-menu event handlers.
+   *
+   * @param context - The registration context.
+   */
+  async onRegistered(context) {
+    await super.onRegistered(context);
+    this.activeFileProvider = context.activeFileProvider;
+    context.menuEventRegistrar.registerFileMenuEventHandler(this.handleAbstractFileMenu.bind(this));
+    context.menuEventRegistrar.registerFilesMenuEventHandler(this.handleAbstractFilesMenu.bind(this));
+  }
+  /**
+   * Checks whether the command can execute from the command palette.
+   * Uses the active file as the target.
+   *
+   * @returns Whether the command can execute.
+   */
+  canExecute() {
+    if (!this.shouldAddToCommandPalette()) {
+      return false;
+    }
+    const activeFile = this.getActiveFile();
+    return !!activeFile && this.canExecuteAbstractFile(activeFile);
+  }
+  /**
+   * Checks whether the command can execute for a single abstract file.
+   *
+   * @param _abstractFile - The file or folder.
+   * @returns Whether the command can execute.
+   */
+  canExecuteAbstractFile(_abstractFile) {
+    return true;
+  }
+  /**
+   * Checks whether the command can execute for multiple abstract files.
+   * Default implementation checks each file individually.
+   *
+   * @param abstractFiles - The files or folders.
+   * @returns Whether the command can execute.
+   */
+  canExecuteAbstractFiles(abstractFiles) {
+    return abstractFiles.length > 0 && abstractFiles.every((f) => this.canExecuteAbstractFile(f));
+  }
+  /**
+   * Executes the command from the command palette using the active file.
+   */
+  async execute() {
+    const activeFile = this.getActiveFile();
+    if (activeFile) {
+      await this.executeAbstractFile(activeFile);
+    }
+  }
+  /**
+   * Executes the command for multiple abstract files.
+   * Default implementation executes sequentially.
+   *
+   * @param abstractFiles - The files or folders.
+   */
+  async executeAbstractFiles(abstractFiles) {
+    for (const file of abstractFiles) {
+      await this.executeAbstractFile(file);
+    }
+  }
+  /**
+   * Checks whether the command should appear in the single-file context menu.
+   *
+   * @param _abstractFile - The file or folder.
+   * @param _source - The source of the event.
+   * @param _leaf - The workspace leaf, if available.
+   * @returns Whether to add to the file menu.
+   */
+  shouldAddToAbstractFileMenu(_abstractFile, _source, _leaf) {
+    return false;
+  }
+  /**
+   * Checks whether the command should appear in the multi-file context menu.
+   * Default implementation checks each file individually.
+   *
+   * @param abstractFiles - The files or folders.
+   * @param source - The source of the event.
+   * @param leaf - The workspace leaf, if available.
+   * @returns Whether to add to the files menu.
+   */
+  shouldAddToAbstractFilesMenu(abstractFiles, source, leaf) {
+    return abstractFiles.every((f) => this.shouldAddToAbstractFileMenu(f, source, leaf));
+  }
+  /**
+   * Checks whether the command should appear in the command palette.
+   *
+   * @returns Whether to add to the command palette.
+   */
+  shouldAddToCommandPalette() {
+    return true;
+  }
+  getActiveFile() {
+    return this.activeFileProvider?.getActiveFile() ?? null;
+  }
+  handleAbstractFileMenu(menu, abstractFile, source, leaf) {
+    if (!this.shouldAddToAbstractFileMenu(abstractFile, source, leaf)) {
+      return;
+    }
+    if (!this.canExecuteAbstractFile(abstractFile)) {
+      return;
+    }
+    const section = this.fileMenuSection ?? this.pluginName;
+    if (this.shouldAddCommandToSubmenu) {
+      menu.setSectionSubmenu(section, {
+        icon: this.fileMenuSubmenuIcon ?? "",
+        title: section
+      });
+    }
+    menu.addItem((item) => {
+      item.setTitle(this.fileMenuItemName ?? this.name).setIcon(this.icon).setSection(section).onClick(() => {
+        invokeAsyncSafely(() => this.executeAbstractFile(abstractFile));
+      });
+    });
+  }
+  handleAbstractFilesMenu(menu, abstractFiles, source, leaf) {
+    if (!this.shouldAddToAbstractFilesMenu(abstractFiles, source, leaf)) {
+      return;
+    }
+    if (!this.canExecuteAbstractFiles(abstractFiles)) {
+      return;
+    }
+    const section = this.filesMenuSection ?? this.fileMenuSection ?? this.pluginName;
+    if (this.shouldAddCommandToSubmenu) {
+      menu.setSectionSubmenu(section, {
+        icon: this.filesMenuSubmenuIcon ?? this.fileMenuSubmenuIcon ?? "",
+        title: section
+      });
+    }
+    menu.addItem((item) => {
+      item.setTitle(this.filesMenuItemName ?? this.fileMenuItemName ?? this.name).setIcon(this.icon).setSection(section).onClick(() => {
+        invokeAsyncSafely(() => this.executeAbstractFiles(abstractFiles));
+      });
+    });
+  }
+}
+export {
+  AbstractFileCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/command-handlers/abstract-file-command-handler.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Command handler for abstract file commands with file/files menu integration.\n */\n\nimport type {\n  IconName,\n  Menu,\n  TAbstractFile,\n  WorkspaceLeaf\n} from 'obsidian';\n\nimport type {\n  ActiveFileProvider,\n  CommandHandlerParams,\n  CommandHandlerRegistrationContext\n} from './command-handler.ts';\n\nimport { invokeAsyncSafely } from '../../async.ts';\nimport { GlobalCommandHandler } from './global-command-handler.ts';\n\n/**\n * Parameters for creating an abstract file command handler.\n */\nexport interface AbstractFileCommandHandlerParams extends CommandHandlerParams {\n  /**\n   * The item name to use in the single-file menu.\n   */\n  readonly fileMenuItemName?: string | undefined;\n\n  /**\n   * The section to use in the single-file menu.\n   */\n  readonly fileMenuSection?: string | undefined;\n\n  /**\n   * The icon to use in the single-file menu submenu.\n   */\n  readonly fileMenuSubmenuIcon?: IconName | undefined;\n\n  /**\n   * The item name to use in the multi-file menu.\n   */\n  readonly filesMenuItemName?: string | undefined;\n\n  /**\n   * The section to use in the multi-file menu.\n   */\n  readonly filesMenuSection?: string | undefined;\n\n  /**\n   * The icon to use in the multi-file menu submenu.\n   */\n  readonly filesMenuSubmenuIcon?: IconName | undefined;\n\n  /**\n   * Whether to add the command to a submenu.\n   */\n  readonly shouldAddCommandToSubmenu?: boolean | undefined;\n}\n\n/**\n * Command handler for abstract file commands.\n *\n * Handles both single-file and multi-file context menus.\n * Subclasses override {@link canExecuteAbstractFile} and {@link executeAbstractFile}.\n */\nexport abstract class AbstractFileCommandHandler extends GlobalCommandHandler {\n  /**\n   * Gets the item name to use in the single-file menu.\n   *\n   * @returns The item name, or `undefined` to use the command name.\n   */\n  protected get fileMenuItemName(): string | undefined {\n    return this._fileMenuItemName;\n  }\n\n  /**\n   * Gets the section to use in the single-file menu.\n   *\n   * @returns The section name, or `undefined` to use the plugin name.\n   */\n  protected get fileMenuSection(): string | undefined {\n    return this._fileMenuSection;\n  }\n\n  /**\n   * Gets the icon to use in the single-file menu submenu.\n   *\n   * @returns The icon, or `undefined` for no icon.\n   */\n  protected get fileMenuSubmenuIcon(): IconName | undefined {\n    return this._fileMenuSubmenuIcon;\n  }\n\n  /**\n   * Gets the item name to use in the multi-file menu.\n   *\n   * @returns The item name, or `undefined` to fall back to single-file item name.\n   */\n  protected get filesMenuItemName(): string | undefined {\n    return this._filesMenuItemName;\n  }\n\n  /**\n   * Gets the section to use in the multi-file menu.\n   *\n   * @returns The section name, or `undefined` to fall back to single-file section.\n   */\n  protected get filesMenuSection(): string | undefined {\n    return this._filesMenuSection;\n  }\n\n  /**\n   * Gets the icon to use in the multi-file menu submenu.\n   *\n   * @returns The icon, or `undefined` to fall back to single-file submenu icon.\n   */\n  protected get filesMenuSubmenuIcon(): IconName | undefined {\n    return this._filesMenuSubmenuIcon;\n  }\n\n  /**\n   * Gets whether to add the command to a submenu.\n   *\n   * @returns Whether to add to a submenu.\n   */\n  protected get shouldAddCommandToSubmenu(): boolean | undefined {\n    return this._shouldAddCommandToSubmenu;\n  }\n\n  private readonly _fileMenuItemName?: string | undefined;\n  private readonly _fileMenuSection?: string | undefined;\n  private readonly _fileMenuSubmenuIcon?: IconName | undefined;\n  private readonly _filesMenuItemName?: string | undefined;\n  private readonly _filesMenuSection?: string | undefined;\n  private readonly _filesMenuSubmenuIcon?: IconName | undefined;\n  private readonly _shouldAddCommandToSubmenu?: boolean | undefined;\n  private activeFileProvider?: ActiveFileProvider;\n\n  /**\n   * Creates a new abstract file command handler.\n   *\n   * @param params - The parameters for the abstract file command handler.\n   */\n  public constructor(params: AbstractFileCommandHandlerParams) {\n    super(params);\n    this._fileMenuItemName = params.fileMenuItemName;\n    this._fileMenuSection = params.fileMenuSection;\n    this._fileMenuSubmenuIcon = params.fileMenuSubmenuIcon;\n    this._filesMenuItemName = params.filesMenuItemName;\n    this._filesMenuSection = params.filesMenuSection;\n    this._filesMenuSubmenuIcon = params.filesMenuSubmenuIcon;\n    this._shouldAddCommandToSubmenu = params.shouldAddCommandToSubmenu;\n  }\n\n  /**\n   * Registers file-menu and files-menu event handlers.\n   *\n   * @param context - The registration context.\n   */\n  public override async onRegistered(context: CommandHandlerRegistrationContext): Promise<void> {\n    await super.onRegistered(context);\n    this.activeFileProvider = context.activeFileProvider;\n    context.menuEventRegistrar.registerFileMenuEventHandler(this.handleAbstractFileMenu.bind(this));\n    context.menuEventRegistrar.registerFilesMenuEventHandler(this.handleAbstractFilesMenu.bind(this));\n  }\n\n  /**\n   * Checks whether the command can execute from the command palette.\n   * Uses the active file as the target.\n   *\n   * @returns Whether the command can execute.\n   */\n  protected override canExecute(): boolean {\n    if (!this.shouldAddToCommandPalette()) {\n      return false;\n    }\n\n    const activeFile = this.getActiveFile();\n    return !!activeFile && this.canExecuteAbstractFile(activeFile);\n  }\n\n  /**\n   * Checks whether the command can execute for a single abstract file.\n   *\n   * @param _abstractFile - The file or folder.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteAbstractFile(_abstractFile: TAbstractFile): boolean {\n    return true;\n  }\n\n  /**\n   * Checks whether the command can execute for multiple abstract files.\n   * Default implementation checks each file individually.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean {\n    return abstractFiles.length > 0 && abstractFiles.every((f) => this.canExecuteAbstractFile(f));\n  }\n\n  /**\n   * Executes the command from the command palette using the active file.\n   */\n  protected override async execute(): Promise<void> {\n    const activeFile = this.getActiveFile();\n    if (activeFile) {\n      await this.executeAbstractFile(activeFile);\n    }\n  }\n\n  /**\n   * Executes the command for a single abstract file.\n   *\n   * @param abstractFile - The file or folder.\n   */\n  protected abstract executeAbstractFile(abstractFile: TAbstractFile): Promise<void>;\n\n  /**\n   * Executes the command for multiple abstract files.\n   * Default implementation executes sequentially.\n   *\n   * @param abstractFiles - The files or folders.\n   */\n  protected async executeAbstractFiles(abstractFiles: TAbstractFile[]): Promise<void> {\n    for (const file of abstractFiles) {\n      await this.executeAbstractFile(file);\n    }\n  }\n\n  /**\n   * Checks whether the command should appear in the single-file context menu.\n   *\n   * @param _abstractFile - The file or folder.\n   * @param _source - The source of the event.\n   * @param _leaf - The workspace leaf, if available.\n   * @returns Whether to add to the file menu.\n   */\n  protected shouldAddToAbstractFileMenu(_abstractFile: TAbstractFile, _source: string, _leaf?: WorkspaceLeaf): boolean {\n    return false;\n  }\n\n  /**\n   * Checks whether the command should appear in the multi-file context menu.\n   * Default implementation checks each file individually.\n   *\n   * @param abstractFiles - The files or folders.\n   * @param source - The source of the event.\n   * @param leaf - The workspace leaf, if available.\n   * @returns Whether to add to the files menu.\n   */\n  protected shouldAddToAbstractFilesMenu(abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): boolean {\n    return abstractFiles.every((f) => this.shouldAddToAbstractFileMenu(f, source, leaf));\n  }\n\n  /**\n   * Checks whether the command should appear in the command palette.\n   *\n   * @returns Whether to add to the command palette.\n   */\n  protected shouldAddToCommandPalette(): boolean {\n    return true;\n  }\n\n  private getActiveFile(): null | TAbstractFile {\n    return this.activeFileProvider?.getActiveFile() ?? null;\n  }\n\n  private handleAbstractFileMenu(menu: Menu, abstractFile: TAbstractFile, source: string, leaf?: WorkspaceLeaf): void {\n    if (!this.shouldAddToAbstractFileMenu(abstractFile, source, leaf)) {\n      return;\n    }\n\n    if (!this.canExecuteAbstractFile(abstractFile)) {\n      return;\n    }\n\n    const section = this.fileMenuSection ?? this.pluginName;\n    if (this.shouldAddCommandToSubmenu) {\n      menu.setSectionSubmenu(section, {\n        icon: this.fileMenuSubmenuIcon ?? '',\n        title: section\n      });\n    }\n\n    menu.addItem((item) => {\n      item\n        .setTitle(this.fileMenuItemName ?? this.name)\n        .setIcon(this.icon)\n        .setSection(section)\n        .onClick(() => {\n          invokeAsyncSafely(() => this.executeAbstractFile(abstractFile));\n        });\n    });\n  }\n\n  private handleAbstractFilesMenu(menu: Menu, abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): void {\n    if (!this.shouldAddToAbstractFilesMenu(abstractFiles, source, leaf)) {\n      return;\n    }\n\n    if (!this.canExecuteAbstractFiles(abstractFiles)) {\n      return;\n    }\n\n    const section = this.filesMenuSection ?? this.fileMenuSection ?? this.pluginName;\n    if (this.shouldAddCommandToSubmenu) {\n      menu.setSectionSubmenu(section, {\n        icon: this.filesMenuSubmenuIcon ?? this.fileMenuSubmenuIcon ?? '',\n        title: section\n      });\n    }\n\n    menu.addItem((item) => {\n      item\n        .setTitle(this.filesMenuItemName ?? this.fileMenuItemName ?? this.name)\n        .setIcon(this.icon)\n        .setSection(section)\n        .onClick(() => {\n          invokeAsyncSafely(() => this.executeAbstractFiles(abstractFiles));\n        });\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/command-handlers/app-active-file-provider.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file
+ *
+ * App-backed implementation of {@link ActiveFileProvider}.
+ */
+import type { App, TFile } from 'obsidian';
+import type { ActiveFileProvider } from './command-handler.mjs';
+/**
+ * {@link ActiveFileProvider} backed by Obsidian's {@link App}.
+ */
+export declare class AppActiveFileProvider implements ActiveFileProvider {
+    private readonly app;
+    /**
+     * Creates a new app-backed active file provider.
+     *
+     * @param app - The Obsidian app instance.
+     */
+    constructor(app: App);
+    /**
+     * Gets the currently active file from the workspace.
+     *
+     * @returns The active file, or `null` if no file is active.
+     */
+    getActiveFile(): null | TFile;
+}

package/dist/lib/esm/obsidian/command-handlers/app-active-file-provider.mjs

@@ -0,0 +1,46 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+class AppActiveFileProvider {
+  /**
+   * Creates a new app-backed active file provider.
+   *
+   * @param app - The Obsidian app instance.
+   */
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  /**
+   * Gets the currently active file from the workspace.
+   *
+   * @returns The active file, or `null` if no file is active.
+   */
+  getActiveFile() {
+    return this.app.workspace.getActiveFile();
+  }
+}
+export {
+  AppActiveFileProvider
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbW1hbmQtaGFuZGxlcnMvYXBwLWFjdGl2ZS1maWxlLXByb3ZpZGVyLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQXBwLWJhY2tlZCBpbXBsZW1lbnRhdGlvbiBvZiB7QGxpbmsgQWN0aXZlRmlsZVByb3ZpZGVyfS5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIEFwcCxcbiAgVEZpbGVcbn0gZnJvbSAnb2JzaWRpYW4nO1xuXG5pbXBvcnQgdHlwZSB7IEFjdGl2ZUZpbGVQcm92aWRlciB9IGZyb20gJy4vY29tbWFuZC1oYW5kbGVyLnRzJztcblxuLyoqXG4gKiB7QGxpbmsgQWN0aXZlRmlsZVByb3ZpZGVyfSBiYWNrZWQgYnkgT2JzaWRpYW4ncyB7QGxpbmsgQXBwfS5cbiAqL1xuZXhwb3J0IGNsYXNzIEFwcEFjdGl2ZUZpbGVQcm92aWRlciBpbXBsZW1lbnRzIEFjdGl2ZUZpbGVQcm92aWRlciB7XG4gIC8qKlxuICAgKiBDcmVhdGVzIGEgbmV3IGFwcC1iYWNrZWQgYWN0aXZlIGZpbGUgcHJvdmlkZXIuXG4gICAqXG4gICAqIEBwYXJhbSBhcHAgLSBUaGUgT2JzaWRpYW4gYXBwIGluc3RhbmNlLlxuICAgKi9cbiAgcHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgYXBwOiBBcHApIHt9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIGN1cnJlbnRseSBhY3RpdmUgZmlsZSBmcm9tIHRoZSB3b3Jrc3BhY2UuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBhY3RpdmUgZmlsZSwgb3IgYG51bGxgIGlmIG5vIGZpbGUgaXMgYWN0aXZlLlxuICAgKi9cbiAgcHVibGljIGdldEFjdGl2ZUZpbGUoKTogbnVsbCB8IFRGaWxlIHtcbiAgICByZXR1cm4gdGhpcy5hcHAud29ya3NwYWNlLmdldEFjdGl2ZUZpbGUoKTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFnQk8sTUFBTSxzQkFBb0Q7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNeEQsWUFBNkIsS0FBVTtBQUFWO0FBQUEsRUFBVztBQUFBLEVBQVg7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPN0IsZ0JBQThCO0FBQ25DLFdBQU8sS0FBSyxJQUFJLFVBQVUsY0FBYztBQUFBLEVBQzFDO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==