obsidian-integration-testing 1.1.1 → 1.2.0

package/dist/lib/cjs/transport.d.cts

@@ -0,0 +1,86 @@
+/**
+ * @file
+ *
+ * Defines the transport interface for communicating with a running Obsidian instance.
+ */
+/**
+ * A pluggable transport that evaluates JavaScript expressions inside a running
+ * Obsidian instance and manages vault lifecycle.
+ *
+ * Implementations handle the platform-specific details:
+ * - {@link DesktopCliTransport} — Desktop Obsidian via CLI (`obsidian eval`)
+ * - {@link DesktopCdpTransport} — Desktop Obsidian via Chrome DevTools Protocol
+ * - {@link AppiumTransport} — Mobile Obsidian via Appium WebView JS injection
+ */
+export interface ObsidianTransport {
+    /**
+     * Disposes of transport resources (e.g. WebSocket connections, Appium sessions).
+     */
+    dispose?(): Promise<void>;
+    /**
+     * Evaluates a JavaScript expression string inside Obsidian and returns the
+     * raw string result.
+     *
+     * The transport normalizes the output — stripping transport-specific prefixes
+     * and handling transport-specific errors — so callers receive a clean result
+     * string (e.g. a JSON string, or `(no output)`).
+     *
+     * @param expression - A self-contained JavaScript expression (typically an async IIFE).
+     * @param options - Evaluation options including the working directory.
+     * @returns The raw result string from Obsidian.
+     */
+    evaluate(expression: string, options: TransportEvalOptions): Promise<string>;
+    /**
+     * Whether this transport targets a mobile Obsidian instance.
+     *
+     * When `true`, desktop-only plugins (with `isDesktopOnly: true` in manifest)
+     * will refuse to run integration tests.
+     */
+    isMobile: boolean;
+    /**
+     * Runs transport-specific preflight checks before evaluation.
+     *
+     * For example, the CLI transport verifies that the vault is registered,
+     * the CLI is enabled, and the CLI binary is in PATH.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    preflightCheck(vaultPath: string): Promise<void>;
+    /**
+     * Pushes files into a vault directory on the target device.
+     *
+     * On desktop this is a no-op (files are written to the local filesystem directly).
+     * On mobile this uses the device's file transfer mechanism (e.g. Appium `pushFile`).
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     * @param files - Map of relative file paths to content strings.
+     */
+    pushFiles?(vaultPath: string, files: Record<string, string>): Promise<void>;
+    /**
+     * Registers a vault path so Obsidian can target it.
+     *
+     * On desktop: uses Electron IPC to open the vault and polls for readiness.
+     * On mobile: pushes vault files to the device and restarts the app.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    registerVault(vaultPath: string): Promise<void>;
+    /**
+     * Unregisters a vault path from the running Obsidian instance.
+     *
+     * On desktop: closes the vault window and removes it from the registry.
+     * On mobile: removes vault files from the device.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    unregisterVault(vaultPath: string): Promise<void>;
+}
+/**
+ * Options for {@link ObsidianTransport.evaluate}.
+ */
+export interface TransportEvalOptions {
+    /**
+     * The working directory (vault path) for the evaluation.
+     */
+    readonly cwd: string;
+}

package/dist/lib/cjs/type-guards.cjs

@@ -39,4 +39,4 @@ function ensureNonNullable(value, errorOrMessage) {
   assertNonNullable,
   ensureNonNullable
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/type-guards.d.cts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Contains utility functions for type guards.
  */

package/dist/lib/cjs/vault-registry.cjs

@@ -22,68 +22,19 @@ __export(vault_registry_exports, {
   unregisterVault: () => unregisterVault
 });
 module.exports = __toCommonJS(vault_registry_exports);
-var import_obsidian_cli = require("./obsidian-cli.cjs");
-const POLL_INTERVAL_MS = 500;
-const POLL_TIMEOUT_MS = 3e4;
-const CLOSE_DELAY_MS = 1e3;
+var import_vitest = require("vitest");
+var import_transport_factory = require("./transport-factory.cjs");
 async function registerVault(vaultPath) {
-  await (0, import_obsidian_cli.evalInObsidian)({
-    args: { vaultPath },
-    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
-    fn({ vaultPath: vaultPath2 }) {
-      window.electron.ipcRenderer.sendSync("vault-open", vaultPath2, false);
-    },
-    shouldSkipPreflightChecks: true
-  });
-  const deadline = Date.now() + POLL_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    try {
-      const basePath = await (0, import_obsidian_cli.evalInObsidian)({
-        fn({ app }) {
-          return app.vault.adapter.getBasePath();
-        },
-        shouldSkipPreflightChecks: true,
-        vaultPath
-      });
-      if (basePath === vaultPath) {
-        return;
-      }
-    } catch {
-    }
-    await new Promise((r) => {
-      setTimeout(r, POLL_INTERVAL_MS);
-    });
-  }
-  throw new Error(`Vault at ${vaultPath} did not become ready within ${String(POLL_TIMEOUT_MS)}ms`);
+  const transport = await (0, import_transport_factory.getOrCreateTransport)((0, import_vitest.inject)("obsidianTransport"));
+  await transport.registerVault(vaultPath);
 }
 async function unregisterVault(vaultPath) {
-  try {
-    await (0, import_obsidian_cli.evalInObsidian)({
-      fn() {
-        setTimeout(() => {
-          window.electron.remote?.getCurrentWindow().destroy();
-        }, 0);
-      },
-      shouldSkipPreflightChecks: true,
-      vaultPath
-    });
-  } catch {
-  }
-  await new Promise((r) => {
-    setTimeout(r, CLOSE_DELAY_MS);
-  });
-  await (0, import_obsidian_cli.evalInObsidian)({
-    args: { vaultPath },
-    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
-    fn({ vaultPath: vaultPath2 }) {
-      window.electron.ipcRenderer.sendSync("vault-remove", vaultPath2);
-    },
-    shouldSkipPreflightChecks: true
-  });
+  const transport = await (0, import_transport_factory.getOrCreateTransport)((0, import_vitest.inject)("obsidianTransport"));
+  await transport.unregisterVault(vaultPath);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   registerVault,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3ZhdWx0LXJlZ2lzdHJ5LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiB2OCBpZ25vcmUgc3RhcnQgLS0gSW50ZWdyYXRpb24tdGltZSBjb2RlIGNvdmVyZWQgYnkgaW50ZWdyYXRpb24gdGVzdHMsIG5vdCB1bml0IHRlc3RzLiAqL1xuXG4vKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICpcbiAqIE1hbmFnZXMgdmF1bHQgcmVnaXN0cmF0aW9uIGluIHRoZSBydW5uaW5nIE9ic2lkaWFuIGluc3RhbmNlLlxuICovXG5cbmltcG9ydCB0eXBlIHsgRmlsZVN5c3RlbUFkYXB0ZXIgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB7IGV2YWxJbk9ic2lkaWFuIH0gZnJvbSAnLi9vYnNpZGlhbi1jbGkuY2pzJztcblxuY29uc3QgUE9MTF9JTlRFUlZBTF9NUyA9IDUwMDtcbmNvbnN0IFBPTExfVElNRU9VVF9NUyA9IDMwMDAwO1xuY29uc3QgQ0xPU0VfREVMQVlfTVMgPSAxMDAwO1xuXG5pbnRlcmZhY2UgRWxlY3Ryb24ge1xuICByZW1vdGU6IEVsZWN0cm9uUmVtb3RlO1xufVxuXG5pbnRlcmZhY2UgRWxlY3Ryb25SZW1vdGUge1xuICBnZXRDdXJyZW50V2luZG93KCk6IEdldEN1cnJlbnRXaW5kb3dSZXN1bHQ7XG59XG5cbmludGVyZmFjZSBHZXRDdXJyZW50V2luZG93UmVzdWx0IHtcbiAgZGVzdHJveSgpOiB2b2lkO1xufVxuXG4vKipcbiAqIFJlZ2lzdGVycyBhIHZhdWx0IHBhdGggaW4gdGhlIHJ1bm5pbmcgT2JzaWRpYW4gaW5zdGFuY2Ugc28gdGhlIENMSSBjYW4gdGFyZ2V0IGl0IHZpYSBgY3dkYC5cbiAqXG4gKiBVc2VzIHRoZSBgdmF1bHQtb3BlbmAgSVBDIHRvIHJlZ2lzdGVyIGFuZCBvcGVuIHRoZSB2YXVsdCwgdGhlbiBwb2xscyB1bnRpbFxuICogdGhlIHZhdWx0J3MgQ0xJIGlzIHJlYWR5IGFuZCBgZ2V0QmFzZVBhdGgoKWAgbWF0Y2hlcyBgdmF1bHRQYXRoYC5cbiAqXG4gKiBAcGFyYW0gdmF1bHRQYXRoIC0gVGhlIGFic29sdXRlIHBhdGggdG8gdGhlIHZhdWx0IGZvbGRlci5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJlZ2lzdGVyVmF1bHQodmF1bHRQYXRoOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgLy8gT3BlbiB0aGUgdmF1bHQgdmlhIElQQy4gVGhlIHNlbmRTeW5jIHJldHVybiB2YWx1ZSBpcyB1bnJlbGlhYmxlXG4gIC8vIChDTEkgb3V0cHV0IG1heSBiZSBsb3N0IHdoZW4gdGhlIG5ldyB3aW5kb3cgb3BlbnMpLCBzbyB3ZSBpZ25vcmUgaXRcbiAgLy8gQW5kIHBvbGwgZm9yIHJlYWRpbmVzcyBpbnN0ZWFkLlxuICBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgYXJnczogeyB2YXVsdFBhdGggfSxcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIE5vIGFjdHVhbCBzaGFkb3dpbmcgYXMgdGhlIGZ1bmN0aW9uIGlzIGV4ZWN1dGVkIGV4dGVybmFsbHkuXG4gICAgZm4oeyB2YXVsdFBhdGggfSk6IHZvaWQge1xuICAgICAgd2luZG93LmVsZWN0cm9uLmlwY1JlbmRlcmVyLnNlbmRTeW5jKCd2YXVsdC1vcGVuJywgdmF1bHRQYXRoLCBmYWxzZSk7XG4gICAgfSxcbiAgICBzaG91bGRTa2lwUHJlZmxpZ2h0Q2hlY2tzOiB0cnVlXG4gIH0pO1xuXG4gIC8vIFBvbGwgdW50aWwgdGhlIG5ldyB2YXVsdCdzIENMSSByZXNwb25kcyB3aXRoIHRoZSBjb3JyZWN0IGJhc2VQYXRoLlxuICBjb25zdCBkZWFkbGluZSA9IERhdGUubm93KCkgKyBQT0xMX1RJTUVPVVRfTVM7XG4gIHdoaWxlIChEYXRlLm5vdygpIDwgZGVhZGxpbmUpIHtcbiAgICB0cnkge1xuICAgICAgY29uc3QgYmFzZVBhdGggPSBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgICAgIGZuKHsgYXBwIH0pOiBzdHJpbmcge1xuICAgICAgICAgIHJldHVybiAoYXBwLnZhdWx0LmFkYXB0ZXIgYXMgRmlsZVN5c3RlbUFkYXB0ZXIpLmdldEJhc2VQYXRoKCk7XG4gICAgICAgIH0sXG4gICAgICAgIHNob3VsZFNraXBQcmVmbGlnaHRDaGVja3M6IHRydWUsXG4gICAgICAgIHZhdWx0UGF0aFxuICAgICAgfSk7XG4gICAgICBpZiAoYmFzZVBhdGggPT09IHZhdWx0UGF0aCkge1xuICAgICAgICByZXR1cm47XG4gICAgICB9XG4gICAgfSBjYXRjaCB7XG4gICAgICAvLyBWYXVsdCBub3QgcmVhZHkgeWV0LlxuICAgIH1cbiAgICBhd2FpdCBuZXcgUHJvbWlzZSgocikgPT4ge1xuICAgICAgc2V0VGltZW91dChyLCBQT0xMX0lOVEVSVkFMX01TKTtcbiAgICB9KTtcbiAgfVxuICB0aHJvdyBuZXcgRXJyb3IoYFZhdWx0IGF0ICR7dmF1bHRQYXRofSBkaWQgbm90IGJlY29tZSByZWFkeSB3aXRoaW4gJHtTdHJpbmcoUE9MTF9USU1FT1VUX01TKX1tc2ApO1xufVxuXG4vKipcbiAqIFVucmVnaXN0ZXJzIGEgdmF1bHQgcGF0aCBmcm9tIHRoZSBydW5uaW5nIE9ic2lkaWFuIGluc3RhbmNlLlxuICpcbiAqIFNjaGVkdWxlcyB0aGUgdmF1bHQgd2luZG93IHRvIGNsb3NlLCB3YWl0cyBmb3IgaXQsIHRoZW4gcmVtb3Zlc1xuICogdGhlIHZhdWx0IGZyb20gdGhlIHJlZ2lzdHJ5IHZpYSBgdmF1bHQtcmVtb3ZlYCBJUEMuXG4gKlxuICogQHBhcmFtIHZhdWx0UGF0aCAtIFRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSB2YXVsdCBmb2xkZXIuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB1bnJlZ2lzdGVyVmF1bHQodmF1bHRQYXRoOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgLy8gU2NoZWR1bGUgdGhlIHZhdWx0IHdpbmRvdyB0byBjbG9zZSBmcm9tIHdpdGhpbiBpdHMgb3duIGNvbnRleHQuXG4gIC8vIFVzZSBzZXRUaW1lb3V0IHNvIHRoZSBDTEkgcmVzcG9uc2UgaXMgc2VudCBiZWZvcmUgdGhlIHdpbmRvdyBjbG9zZXMuXG4gIHRyeSB7XG4gICAgYXdhaXQgZXZhbEluT2JzaWRpYW4oe1xuICAgICAgZm4oKTogdm9pZCB7XG4gICAgICAgIHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgICAgICh3aW5kb3cuZWxlY3Ryb24gYXMgUGFydGlhbDxFbGVjdHJvbj4pLnJlbW90ZT8uZ2V0Q3VycmVudFdpbmRvdygpLmRlc3Ryb3koKTtcbiAgICAgICAgfSwgMCk7XG4gICAgICB9LFxuICAgICAgc2hvdWxkU2tpcFByZWZsaWdodENoZWNrczogdHJ1ZSxcbiAgICAgIHZhdWx0UGF0aFxuICAgIH0pO1xuICB9IGNhdGNoIHtcbiAgICAvLyBUaGUgd2luZG93IG1heSBoYXZlIGNsb3NlZCBiZWZvcmUgdGhlIHJlc3BvbnNlIHdhcyBzZW50IFx1MjAxNCB0aGF0J3MgT0suXG4gIH1cblxuICAvLyBXYWl0IGZvciB0aGUgd2luZG93IHRvIGFjdHVhbGx5IGNsb3NlLlxuICBhd2FpdCBuZXcgUHJvbWlzZSgocikgPT4ge1xuICAgIHNldFRpbWVvdXQociwgQ0xPU0VfREVMQVlfTVMpO1xuICB9KTtcblxuICAvLyBSZW1vdmUgZnJvbSB0aGUgcmVnaXN0cnkgKGZyb20gYW55IHJlbWFpbmluZyB2YXVsdCdzIGNvbnRleHQpLlxuICBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgYXJnczogeyB2YXVsdFBhdGggfSxcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIE5vIGFjdHVhbCBzaGFkb3dpbmcgYXMgdGhlIGZ1bmN0aW9uIGlzIGV4ZWN1dGVkIGV4dGVybmFsbHkuXG4gICAgZm4oeyB2YXVsdFBhdGggfSk6IHZvaWQge1xuICAgICAgd2luZG93LmVsZWN0cm9uLmlwY1JlbmRlcmVyLnNlbmRTeW5jKCd2YXVsdC1yZW1vdmUnLCB2YXVsdFBhdGgpO1xuICAgIH0sXG4gICAgc2hvdWxkU2tpcFByZWZsaWdodENoZWNrczogdHJ1ZVxuICB9KTtcbn1cblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVVBLDBCQUErQjtBQUUvQixNQUFNLG1CQUFtQjtBQUN6QixNQUFNLGtCQUFrQjtBQUN4QixNQUFNLGlCQUFpQjtBQXNCdkIsZUFBc0IsY0FBYyxXQUFrQztBQUlwRSxZQUFNLG9DQUFlO0FBQUEsSUFDbkIsTUFBTSxFQUFFLFVBQVU7QUFBQTtBQUFBLElBRWxCLEdBQUcsRUFBRSxXQUFBQSxXQUFVLEdBQVM7QUFDdEIsYUFBTyxTQUFTLFlBQVksU0FBUyxjQUFjQSxZQUFXLEtBQUs7QUFBQSxJQUNyRTtBQUFBLElBQ0EsMkJBQTJCO0FBQUEsRUFDN0IsQ0FBQztBQUdELFFBQU0sV0FBVyxLQUFLLElBQUksSUFBSTtBQUM5QixTQUFPLEtBQUssSUFBSSxJQUFJLFVBQVU7QUFDNUIsUUFBSTtBQUNGLFlBQU0sV0FBVyxVQUFNLG9DQUFlO0FBQUEsUUFDcEMsR0FBRyxFQUFFLElBQUksR0FBVztBQUNsQixpQkFBUSxJQUFJLE1BQU0sUUFBOEIsWUFBWTtBQUFBLFFBQzlEO0FBQUEsUUFDQSwyQkFBMkI7QUFBQSxRQUMzQjtBQUFBLE1BQ0YsQ0FBQztBQUNELFVBQUksYUFBYSxXQUFXO0FBQzFCO0FBQUEsTUFDRjtBQUFBLElBQ0YsUUFBUTtBQUFBLElBRVI7QUFDQSxVQUFNLElBQUksUUFBUSxDQUFDLE1BQU07QUFDdkIsaUJBQVcsR0FBRyxnQkFBZ0I7QUFBQSxJQUNoQyxDQUFDO0FBQUEsRUFDSDtBQUNBLFFBQU0sSUFBSSxNQUFNLFlBQVksU0FBUyxnQ0FBZ0MsT0FBTyxlQUFlLENBQUMsSUFBSTtBQUNsRztBQVVBLGVBQXNCLGdCQUFnQixXQUFrQztBQUd0RSxNQUFJO0FBQ0YsY0FBTSxvQ0FBZTtBQUFBLE1BQ25CLEtBQVc7QUFDVCxtQkFBVyxNQUFNO0FBQ2YsVUFBQyxPQUFPLFNBQStCLFFBQVEsaUJBQWlCLEVBQUUsUUFBUTtBQUFBLFFBQzVFLEdBQUcsQ0FBQztBQUFBLE1BQ047QUFBQSxNQUNBLDJCQUEyQjtBQUFBLE1BQzNCO0FBQUEsSUFDRixDQUFDO0FBQUEsRUFDSCxRQUFRO0FBQUEsRUFFUjtBQUdBLFFBQU0sSUFBSSxRQUFRLENBQUMsTUFBTTtBQUN2QixlQUFXLEdBQUcsY0FBYztBQUFBLEVBQzlCLENBQUM7QUFHRCxZQUFNLG9DQUFlO0FBQUEsSUFDbkIsTUFBTSxFQUFFLFVBQVU7QUFBQTtBQUFBLElBRWxCLEdBQUcsRUFBRSxXQUFBQSxXQUFVLEdBQVM7QUFDdEIsYUFBTyxTQUFTLFlBQVksU0FBUyxnQkFBZ0JBLFVBQVM7QUFBQSxJQUNoRTtBQUFBLElBQ0EsMkJBQTJCO0FBQUEsRUFDN0IsQ0FBQztBQUNIOyIsCiAgIm5hbWVzIjogWyJ2YXVsdFBhdGgiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/vault-registry.d.cts

@@ -1,8 +1,7 @@
 /**
- * Registers a vault path in the running Obsidian instance so the CLI can target it via `cwd`.
+ * Registers a vault path in the running Obsidian instance.
  *
- * Uses the `vault-open` IPC to register and open the vault, then polls until
- * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.
+ * Delegates to the active transport's {@link ObsidianTransport.registerVault}.
  *
  * @param vaultPath - The absolute path to the vault folder.
  */
@@ -10,8 +9,7 @@ export declare function registerVault(vaultPath: string): Promise<void>;
 /**
  * Unregisters a vault path from the running Obsidian instance.
  *
- * Schedules the vault window to close, waits for it, then removes
- * the vault from the registry via `vault-remove` IPC.
+ * Delegates to the active transport's {@link ObsidianTransport.unregisterVault}.
  *
  * @param vaultPath - The absolute path to the vault folder.
  */

package/dist/lib/esm/context-id.d.mts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Typed context identifiers for persisting non-serializable values
  * across {@link evalInObsidian} calls.

package/dist/lib/esm/context-id.mjs

@@ -56,4 +56,4 @@ class ContextId {
 export {
   ContextId
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbnRleHQtaWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBUeXBlZCBjb250ZXh0IGlkZW50aWZpZXJzIGZvciBwZXJzaXN0aW5nIG5vbi1zZXJpYWxpemFibGUgdmFsdWVzXG4gKiBhY3Jvc3Mge0BsaW5rIGV2YWxJbk9ic2lkaWFufSBjYWxscy5cbiAqL1xuXG5pbXBvcnQgeyBldmFsSW5PYnNpZGlhbiB9IGZyb20gJy4vb2JzaWRpYW4tY2xpLm1qcyc7XG5cbi8qKlxuICogV3JhcHMgYSB7QGxpbmsgQ29udGV4dE9mfSBleHRyYWN0aW9uIGludG8gYW4gb2JqZWN0IHdpdGggYSBgY29udGV4dGAgcHJvcGVydHkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29udGV4dEFyZ3M8VENvbnRleHRJZCBleHRlbmRzIENvbnRleHRJZDx1bmtub3duPiB8IHVuZGVmaW5lZCA9IHVuZGVmaW5lZD4ge1xuICBjb250ZXh0OiBDb250ZXh0T2Y8VENvbnRleHRJZD47XG59XG5cbi8qKlxuICogRXh0cmFjdHMgdGhlIGNvbnRleHQgdHlwZSBmcm9tIGEge0BsaW5rIENvbnRleHRJZH0uXG4gKi9cbmV4cG9ydCB0eXBlIENvbnRleHRPZjxUPiA9IFQgZXh0ZW5kcyBDb250ZXh0SWQ8aW5mZXIgQ29udGV4dD4gPyBDb250ZXh0IDogbmV2ZXI7XG5cbi8qKlxuICogQSB0eXBlZCBjb250ZXh0IGlkZW50aWZpZXIgZm9yIHBlcnNpc3Rpbmcgbm9uLXNlcmlhbGl6YWJsZSB2YWx1ZXNcbiAqIGFjcm9zcyB7QGxpbmsgZXZhbEluT2JzaWRpYW59IGNhbGxzLlxuICpcbiAqIFRoZSBjb250ZXh0IGlzIGEgcGVyc2lzdGVudCBvYmplY3Qgc3RvcmVkIG9uIGB3aW5kb3dgIGluIHRoZSBPYnNpZGlhbiBwcm9jZXNzLlxuICogQWxsIGNhbGxzIHNoYXJpbmcgdGhlIHNhbWUgYENvbnRleHRJZGAgc2hhcmUgdGhlIHNhbWUgY29udGV4dCBvYmplY3QsXG4gKiBhbGxvd2luZyBub24tc2VyaWFsaXphYmxlIHZhbHVlcyAoZS5nLiBgVEZpbGVgLCBgRWRpdG9yYCkgdG8gc3Vydml2ZSBhY3Jvc3MgY2FsbHMuXG4gKlxuICogSW1wbGVtZW50cyBgQXN5bmNEaXNwb3NhYmxlYCBmb3IgdXNlIHdpdGggYGF3YWl0IHVzaW5nYC5cbiAqL1xuZXhwb3J0IGNsYXNzIENvbnRleHRJZDxfQ29udGV4dD4gaW1wbGVtZW50cyBBc3luY0Rpc3Bvc2FibGUge1xuICBwcml2YXRlIHJlYWRvbmx5IGlkOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgY29udGV4dCBpZC5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcigpIHtcbiAgICBjb25zdCBTTElDRV9TVEFSVCA9IDI7XG4gICAgdGhpcy5pZCA9IGBfX2N0eF8ke1N0cmluZyhNYXRoLnJhbmRvbSgpKS5zbGljZShTTElDRV9TVEFSVCl9YDtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZW1vdmVzIHRoaXMgY29udGV4dCBmcm9tIHRoZSBPYnNpZGlhbiBwcm9jZXNzLlxuICAgKlxuICAgKiBAcGFyYW0gdmF1bHRQYXRoIC0gVGhlIHBhdGggdG8gdGhlIE9ic2lkaWFuIHZhdWx0LiBEZWZhdWx0cyB0byBgcHJvY2Vzcy5jd2QoKWAuXG4gICAqL1xuICBwdWJsaWMgYXN5bmMgZGlzcG9zZSh2YXVsdFBhdGg/OiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgICBhcmdzOiB7IGlkOiB0aGlzLmlkIH0sXG4gICAgICAvKiB2OCBpZ25vcmUgc3RhcnQgLS0gU2VyaWFsaXplZCB2aWEgdG9TdHJpbmcoKSBhbmQgZXhlY3V0ZWQgaW5zaWRlIHRoZSBPYnNpZGlhbiBwcm9jZXNzLiBDb3ZlcmVkIGJ5IGludGVncmF0aW9uIHRlc3RzLiAqL1xuICAgICAgZm4oeyBpZCB9KTogdm9pZCB7XG4gICAgICAgIGludGVyZmFjZSBDb250ZXh0SG9sZGVyIHtcbiAgICAgICAgICBfX29ic2lkaWFuQ29udGV4dHNfXzogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG4gICAgICAgIH1cbiAgICAgICAgY29uc3QgaG9sZGVyID0gd2luZG93IGFzIFBhcnRpYWw8Q29udGV4dEhvbGRlcj47XG4gICAgICAgIGlmIChob2xkZXIuX19vYnNpZGlhbkNvbnRleHRzX18pIHtcbiAgICAgICAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWR5bmFtaWMtZGVsZXRlIC0tIE5vIG90aGVyIHdheS5cbiAgICAgICAgICBkZWxldGUgaG9sZGVyLl9fb2JzaWRpYW5Db250ZXh0c19fW2lkXTtcbiAgICAgICAgfVxuICAgICAgfSxcbiAgICAgIC8qIHY4IGlnbm9yZSBzdG9wICovXG4gICAgICBzaG91bGRTa2lwUHJlZmxpZ2h0Q2hlY2tzOiB0cnVlLFxuICAgICAgLi4uKHZhdWx0UGF0aCA9PT0gdW5kZWZpbmVkID8ge30gOiB7IHZhdWx0UGF0aCB9KVxuICAgIH0pO1xuICB9XG5cbiAgLyoqXG4gICAqIERpc3Bvc2VzIHRoaXMgY29udGV4dCBpZC5cbiAgICpcbiAgICogQHJldHVybnMgQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgY29udGV4dCBpZCBpcyBkaXNwb3NlZC5cbiAgICovXG4gIHB1YmxpYyBhc3luYyBbU3ltYm9sLmFzeW5jRGlzcG9zZV0oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgdGhpcy5kaXNwb3NlKCk7XG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyB0aGUgSlNPTiByZXByZXNlbnRhdGlvbiBvZiB0aGUgY29udGV4dCBpZC5cbiAgICpcbiAgICogQHJldHVybnMgVGhlIEpTT04gcmVwcmVzZW50YXRpb24gb2YgdGhlIGNvbnRleHQgaWQuXG4gICAqL1xuICBwdWJsaWMgdG9KU09OKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuaWQ7XG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyB0aGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBjb250ZXh0IGlkLlxuICAgKlxuICAgKiBAcmV0dXJucyBUaGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBjb250ZXh0IGlkLlxuICAgKi9cbiAgcHVibGljIHRvU3RyaW5nKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuaWQ7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQU9BLFNBQVMsc0JBQXNCO0FBd0J4QixNQUFNLFVBQStDO0FBQUEsRUFDekM7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQUtWLGNBQWM7QUFDbkIsVUFBTSxjQUFjO0FBQ3BCLFNBQUssS0FBSyxTQUFTLE9BQU8sS0FBSyxPQUFPLENBQUMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUFBLEVBQzdEO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT0EsTUFBYSxRQUFRLFdBQW1DO0FBQ3RELFVBQU0sZUFBZTtBQUFBLE1BQ25CLE1BQU0sRUFBRSxJQUFJLEtBQUssR0FBRztBQUFBO0FBQUEsTUFFcEIsR0FBRyxFQUFFLEdBQUcsR0FBUztBQUlmLGNBQU0sU0FBUztBQUNmLFlBQUksT0FBTyxzQkFBc0I7QUFFL0IsaUJBQU8sT0FBTyxxQkFBcUIsRUFBRTtBQUFBLFFBQ3ZDO0FBQUEsTUFDRjtBQUFBO0FBQUEsTUFFQSwyQkFBMkI7QUFBQSxNQUMzQixHQUFJLGNBQWMsU0FBWSxDQUFDLElBQUksRUFBRSxVQUFVO0FBQUEsSUFDakQsQ0FBQztBQUFBLEVBQ0g7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPQSxPQUFjLE9BQU8sWUFBWSxJQUFtQjtBQUNsRCxVQUFNLEtBQUssUUFBUTtBQUFBLEVBQ3JCO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT08sU0FBaUI7QUFDdEIsV0FBTyxLQUFLO0FBQUEsRUFDZDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU9PLFdBQW1CO0FBQ3hCLFdBQU8sS0FBSztBQUFBLEVBQ2Q7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/enable-plugin.d.mts

@@ -0,0 +1,44 @@
+/**
+ * @file
+ *
+ * Shared helper for enabling an Obsidian plugin with error capture.
+ * Used by both the global setup and integration tests.
+ */
+import type { CommonArgs } from './obsidian-cli.mjs';
+/**
+ * Parameters for {@link enablePluginWithErrorCapture}.
+ */
+export interface EnablePluginParams {
+    /**
+     * The ID of the plugin to enable.
+     */
+    pluginId: string;
+}
+/**
+ * Result of enabling a plugin with error capture.
+ */
+export interface EnablePluginResult {
+    /**
+     * The error message if the plugin failed to load, or `undefined` if it loaded successfully.
+     */
+    errorMessage: string | undefined;
+    /**
+     * Whether the plugin is in the enabled set after the enable attempt.
+     */
+    isEnabled: boolean;
+}
+/**
+ * Enables a plugin inside Obsidian and captures any load error.
+ *
+ * Monkey-patches `app.plugins.loadPlugin` to intercept errors before
+ * Obsidian's `enablePlugin` try-catch swallows them. The original method
+ * is always restored in a `finally` block.
+ *
+ * Designed to be passed as the `fn` argument to {@link evalInObsidian}.
+ *
+ * @param args - The common args plus the plugin ID.
+ * @param args.app - The Obsidian app instance.
+ * @param args.pluginId - The ID of the plugin to enable.
+ * @returns The enable result with error message and enabled status.
+ */
+export declare function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult>;

package/dist/lib/esm/enable-plugin.mjs

@@ -0,0 +1,30 @@
+async function enablePluginWithErrorCapture({ app, pluginId }) {
+  if (!app.plugins.isEnabled()) {
+    await app.plugins.setEnable(true);
+  }
+  let errorMessage;
+  const origLoadPlugin = app.plugins.loadPlugin;
+  app.plugins.loadPlugin = async function loadPlugin(id, isUserEnabled) {
+    try {
+      const result = await origLoadPlugin.call(this, id, isUserEnabled);
+      errorMessage = void 0;
+      return result;
+    } catch (error) {
+      errorMessage = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  };
+  try {
+    await app.plugins.enablePluginAndSave(pluginId);
+  } finally {
+    app.plugins.loadPlugin = origLoadPlugin;
+  }
+  return {
+    errorMessage,
+    isEnabled: app.plugins.enabledPlugins.has(pluginId)
+  };
+}
+export {
+  enablePluginWithErrorCapture
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/exec.d.mts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Contains utility functions for executing commands.
  */
@@ -16,7 +16,7 @@ export interface ExecArg {
     /**
      * The arguments to batch.
      */
-    batchedArgs: string[];
+    readonly batchedArgs: readonly string[];
 }
 /**
  * Options for {@link exec} that return detailed results.
@@ -25,7 +25,7 @@ export interface ExecDetailedOptions extends ExecOption {
     /**
      * Must be `true` to receive detailed results.
      */
-    withDetails: true;
+    readonly shouldIncludeDetails: true;
 }
 /**
  * Options for executing a command.
@@ -59,19 +59,19 @@ export interface ExecResult {
     /**
      * An exit code of the command. A value of `null` indicates that the process did not exit normally.
      */
-    exitCode: null | number;
+    readonly exitCode: null | number;
     /**
      * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.
      */
-    exitSignal: NodeJS.Signals | null;
+    readonly exitSignal: NodeJS.Signals | null;
     /**
      * A standard error output from the command.
      */
-    stderr: string;
+    readonly stderr: string;
     /**
      * A standard output from the command.
      */
-    stdout: string;
+    readonly stdout: string;
 }
 /**
  * Options for {@link exec} that return only stdout.
@@ -80,7 +80,7 @@ export interface ExecSimpleOptions extends ExecOption {
     /**
      * Must be `false` or omitted to receive only stdout.
      */
-    withDetails?: false;
+    readonly shouldIncludeDetails?: false;
 }
 /**
  * Executes a command.

package/dist/lib/esm/exec.mjs

@@ -33,7 +33,7 @@ function execString(command, options = {}, rawArgs) {
     cwd = process.cwd(),
     isQuiet: quiet = false,
     shouldIgnoreExitCode: ignoreExitCode = false,
-    shouldIncludeDetails: withDetails = false,
+    shouldIncludeDetails = false,
     stdin = ""
   } = options;
   return new Promise((resolve, reject) => {
@@ -66,7 +66,7 @@ function execString(command, options = {}, rawArgs) {
 ${stderr}`));
         return;
       }
-      if (!withDetails) {
+      if (!shouldIncludeDetails) {
         resolve(stdout);
         return;
       }
@@ -82,7 +82,7 @@ ${stderr}`));
         reject(err);
         return;
       }
-      if (!withDetails) {
+      if (!shouldIncludeDetails) {
         resolve(stdout);
         return;
       }
@@ -229,4 +229,4 @@ export {
   exec,
   toCommandLine
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/exec.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcessWithoutNullStreams } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  batchedArgs: string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOption {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  withDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOption {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `true`, returns detailed results.\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOption {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   */\n  withDetails?: false;\n}\n\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n */\nexport async function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n */\nexport function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n */\nexport function exec(command: CommandPart[] | string, options: ExecOption = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${\n            String(maxCommandLength)\n          } on ${process.platform}). Consider using ExecArg with batchedArgs.`\n        )\n      );\n    }\n\n    return execString(commandLine, options, args);\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${\n          String(maxCommandLength)\n        } on ${process.platform}). Consider using ExecArg with batchedArgs.`\n      )\n    );\n  }\n\n  return execString(command, options);\n}\n\n/**\n * Executes a single string command.\n *\n * @param command - The command string.\n * @param options - The exec options.\n * @param rawArgs - The original argument array (if available), used by the\n *   direct-spawn fallback on Windows when the command contains newlines.\n * @returns A Promise resolving to the result.\n */\nfunction execString(command: string, options: ExecOption = {}, rawArgs?: string[]): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails: withDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    const child = spawnViaShell(command, cwd, rawArgs);\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdin.write(stdin);\n    child.stdin.end();\n\n    child.stdout.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stdout.write(data);\n      }\n      stdout += data.toString('utf-8');\n    });\n\n    child.stdout.on('end', () => {\n      stdout = trimEnd(stdout, '\\n');\n    });\n\n    child.stderr.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stderr.write(data);\n      }\n      stderr += data.toString('utf-8');\n    });\n\n    child.stderr.on('end', () => {\n      stderr = trimEnd(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = {\n  DEBUG_COLORS: '1',\n  ...process.env\n};\n\n/**\n * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * using the `CommandLineToArgvW` convention.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(args: string[]): string {\n  return args.map((arg) => argvQuote(arg)).join(' ');\n}\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(arg: string): string {\n  if (arg.length > 0 && !/[\\s\\t\\n\\v\"]/.test(arg)) {\n    return arg;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let i = 0; i < arg.length; i++) {\n    let numBackslashes = 0;\n    while (i < arg.length && arg[i] === '\\\\') {\n      i++;\n      numBackslashes++;\n    }\n\n    if (i === arg.length) {\n      result += '\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = arg.charAt(i);\n    if (ch === '\"') {\n      result += `${'\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"`;\n    } else {\n      result += '\\\\'.repeat(numBackslashes) + ch;\n    }\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally.\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nfunction cmdEscapeCommandLine(commandLine: string): string {\n  return commandLine.replace(CMD_META_RE, '^$&');\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param baseCommand - The base command without batched args.\n * @param batches - The batches of args.\n * @param options - The exec options.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(baseCommand: string, batches: string[][], options: ExecOption): Promise<ExecResult | string> {\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString(batchCommand, options);\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOption): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  /* v8 ignore start -- Always truthy after the length check above. */\n  if (!execArg) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString(fullCommand, options);\n  }\n\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${\n              String(baseCommand.length)\n            } chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches(baseCommand, batches, options);\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param command - The command string to execute.\n * @param cwd - The working directory.\n * @param rawArgs - The original argument array (if available).\n * @returns The spawned child process.\n */\nfunction spawnViaShell(command: string, cwd: string, rawArgs?: string[]): ChildProcessWithoutNullStreams {\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    /* v8 ignore start -- Always truthy; rawArgs comes from the array path which has at least one element. */\n    if (!program) {\n      throw new Error('Command array must not be empty');\n    }\n    /* v8 ignore stop */\n    return spawn(program, args, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env: CHILD_ENV,\n    shell: true,\n    stdio: 'pipe'\n  });\n}\n\n/**\n * Removes a suffix from the end of a string if present.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove.\n * @returns The trimmed string.\n */\nfunction trimEnd(str: string, suffix: string): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n  return str;\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/exec.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcessWithoutNullStreams } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArgs: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOption {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  readonly shouldIncludeDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOption {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `true`, returns detailed results.\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOption {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   */\n  readonly shouldIncludeDetails?: false;\n}\n\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n */\nexport async function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n */\nexport function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n */\nexport function exec(command: CommandPart[] | string, options: ExecOption = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${\n            String(maxCommandLength)\n          } on ${process.platform}). Consider using ExecArg with batchedArgs.`\n        )\n      );\n    }\n\n    return execString(commandLine, options, args);\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${\n          String(maxCommandLength)\n        } on ${process.platform}). Consider using ExecArg with batchedArgs.`\n      )\n    );\n  }\n\n  return execString(command, options);\n}\n\n/**\n * Executes a single string command.\n *\n * @param command - The command string.\n * @param options - The exec options.\n * @param rawArgs - The original argument array (if available), used by the\n *   direct-spawn fallback on Windows when the command contains newlines.\n * @returns A Promise resolving to the result.\n */\nfunction execString(command: string, options: ExecOption = {}, rawArgs?: string[]): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    const child = spawnViaShell(command, cwd, rawArgs);\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdin.write(stdin);\n    child.stdin.end();\n\n    child.stdout.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stdout.write(data);\n      }\n      stdout += data.toString('utf-8');\n    });\n\n    child.stdout.on('end', () => {\n      stdout = trimEnd(stdout, '\\n');\n    });\n\n    child.stderr.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stderr.write(data);\n      }\n      stderr += data.toString('utf-8');\n    });\n\n    child.stderr.on('end', () => {\n      stderr = trimEnd(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = {\n  DEBUG_COLORS: '1',\n  ...process.env\n};\n\n/**\n * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * using the `CommandLineToArgvW` convention.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(args: string[]): string {\n  return args.map((arg) => argvQuote(arg)).join(' ');\n}\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(arg: string): string {\n  if (arg.length > 0 && !/[\\s\\t\\n\\v\"]/.test(arg)) {\n    return arg;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let i = 0; i < arg.length; i++) {\n    let numBackslashes = 0;\n    while (i < arg.length && arg[i] === '\\\\') {\n      i++;\n      numBackslashes++;\n    }\n\n    if (i === arg.length) {\n      result += '\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = arg.charAt(i);\n    if (ch === '\"') {\n      result += `${'\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"`;\n    } else {\n      result += '\\\\'.repeat(numBackslashes) + ch;\n    }\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally.\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nfunction cmdEscapeCommandLine(commandLine: string): string {\n  return commandLine.replace(CMD_META_RE, '^$&');\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param baseCommand - The base command without batched args.\n * @param batches - The batches of args.\n * @param options - The exec options.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(baseCommand: string, batches: string[][], options: ExecOption): Promise<ExecResult | string> {\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString(batchCommand, options);\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOption): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  /* v8 ignore start -- Always truthy after the length check above. */\n  if (!execArg) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString(fullCommand, options);\n  }\n\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${\n              String(baseCommand.length)\n            } chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches(baseCommand, batches, options);\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param command - The command string to execute.\n * @param cwd - The working directory.\n * @param rawArgs - The original argument array (if available).\n * @returns The spawned child process.\n */\nfunction spawnViaShell(command: string, cwd: string, rawArgs?: string[]): ChildProcessWithoutNullStreams {\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    /* v8 ignore start -- Always truthy; rawArgs comes from the array path which has at least one element. */\n    if (!program) {\n      throw new Error('Command array must not be empty');\n    }\n    /* v8 ignore stop */\n    return spawn(program, args, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env: CHILD_ENV,\n    shell: true,\n    stdio: 'pipe'\n  });\n}\n\n/**\n * Removes a suffix from the end of a string if present.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove.\n * @returns The trimmed string.\n */\nfunction trimEnd(str: string, suffix: string): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n  return str;\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength"]
}


package/dist/lib/esm/function-expression.d.mts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Converts a function into a string that is a valid function expression.
  */

package/dist/lib/esm/function-expression.mjs

@@ -14,4 +14,4 @@ const ASYNC_KEYWORD_RE = /^async\b\s*/;
 export {
   getFunctionExpressionString
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/index.d.mts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Contains the entry point for the integration testing module.
  */
@@ -7,4 +7,12 @@ export { ContextId } from './context-id.mjs';
 export type { EvalInObsidianParams } from './obsidian-cli.mjs';
 export { evalInObsidian } from './obsidian-cli.mjs';
 export { TempVault } from './temp-vault.mjs';
+export type { AppiumTransportConfig } from './transport-appium.mjs';
+export { AppiumTransport } from './transport-appium.mjs';
+export type { DesktopCdpTransportConfig } from './transport-desktop-cdp.mjs';
+export { DesktopCdpTransport } from './transport-desktop-cdp.mjs';
+export { DesktopCliTransport } from './transport-desktop-cli.mjs';
+export { createTransportFromOptions } from './transport-factory.mjs';
+export type { ObsidianAndroidAppiumTransportOptions, ObsidianCdpTransportOptions, ObsidianCliTransportOptions, ObsidianTransportOptions } from './transport-options.mjs';
+export type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
 export { registerVault, unregisterVault } from './vault-registry.mjs';

package/dist/lib/esm/index.mjs

@@ -1,15 +1,23 @@
 import { ContextId } from "./context-id.mjs";
 import { evalInObsidian } from "./obsidian-cli.mjs";
 import { TempVault } from "./temp-vault.mjs";
+import { AppiumTransport } from "./transport-appium.mjs";
+import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
+import { DesktopCliTransport } from "./transport-desktop-cli.mjs";
+import { createTransportFromOptions } from "./transport-factory.mjs";
 import {
   registerVault,
   unregisterVault
 } from "./vault-registry.mjs";
 export {
+  AppiumTransport,
   ContextId,
+  DesktopCdpTransport,
+  DesktopCliTransport,
   TempVault,
+  createTransportFromOptions,
   evalInObsidian,
   registerVault,
   unregisterVault
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICpcbiAqIENvbnRhaW5zIHRoZSBlbnRyeSBwb2ludCBmb3IgdGhlIGludGVncmF0aW9uIHRlc3RpbmcgbW9kdWxlLlxuICovXG5cbmV4cG9ydCB7IENvbnRleHRJZCB9IGZyb20gJy4vY29udGV4dC1pZC5tanMnO1xuZXhwb3J0IHR5cGUgeyBFdmFsSW5PYnNpZGlhblBhcmFtcyB9IGZyb20gJy4vb2JzaWRpYW4tY2xpLm1qcyc7XG5leHBvcnQgeyBldmFsSW5PYnNpZGlhbiB9IGZyb20gJy4vb2JzaWRpYW4tY2xpLm1qcyc7XG5leHBvcnQgeyBUZW1wVmF1bHQgfSBmcm9tICcuL3RlbXAtdmF1bHQubWpzJztcbmV4cG9ydCB7XG4gIHJlZ2lzdGVyVmF1bHQsXG4gIHVucmVnaXN0ZXJWYXVsdFxufSBmcm9tICcuL3ZhdWx0LXJlZ2lzdHJ5Lm1qcyc7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFNQSxTQUFTLGlCQUFpQjtBQUUxQixTQUFTLHNCQUFzQjtBQUMvQixTQUFTLGlCQUFpQjtBQUMxQjtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSzsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQ29udGFpbnMgdGhlIGVudHJ5IHBvaW50IGZvciB0aGUgaW50ZWdyYXRpb24gdGVzdGluZyBtb2R1bGUuXG4gKi9cblxuZXhwb3J0IHsgQ29udGV4dElkIH0gZnJvbSAnLi9jb250ZXh0LWlkLm1qcyc7XG5leHBvcnQgdHlwZSB7IEV2YWxJbk9ic2lkaWFuUGFyYW1zIH0gZnJvbSAnLi9vYnNpZGlhbi1jbGkubWpzJztcbmV4cG9ydCB7IGV2YWxJbk9ic2lkaWFuIH0gZnJvbSAnLi9vYnNpZGlhbi1jbGkubWpzJztcbmV4cG9ydCB7IFRlbXBWYXVsdCB9IGZyb20gJy4vdGVtcC12YXVsdC5tanMnO1xuZXhwb3J0IHR5cGUgeyBBcHBpdW1UcmFuc3BvcnRDb25maWcgfSBmcm9tICcuL3RyYW5zcG9ydC1hcHBpdW0ubWpzJztcbmV4cG9ydCB7IEFwcGl1bVRyYW5zcG9ydCB9IGZyb20gJy4vdHJhbnNwb3J0LWFwcGl1bS5tanMnO1xuZXhwb3J0IHR5cGUgeyBEZXNrdG9wQ2RwVHJhbnNwb3J0Q29uZmlnIH0gZnJvbSAnLi90cmFuc3BvcnQtZGVza3RvcC1jZHAubWpzJztcbmV4cG9ydCB7IERlc2t0b3BDZHBUcmFuc3BvcnQgfSBmcm9tICcuL3RyYW5zcG9ydC1kZXNrdG9wLWNkcC5tanMnO1xuZXhwb3J0IHsgRGVza3RvcENsaVRyYW5zcG9ydCB9IGZyb20gJy4vdHJhbnNwb3J0LWRlc2t0b3AtY2xpLm1qcyc7XG5leHBvcnQgeyBjcmVhdGVUcmFuc3BvcnRGcm9tT3B0aW9ucyB9IGZyb20gJy4vdHJhbnNwb3J0LWZhY3RvcnkubWpzJztcbmV4cG9ydCB0eXBlIHtcbiAgT2JzaWRpYW5BbmRyb2lkQXBwaXVtVHJhbnNwb3J0T3B0aW9ucyxcbiAgT2JzaWRpYW5DZHBUcmFuc3BvcnRPcHRpb25zLFxuICBPYnNpZGlhbkNsaVRyYW5zcG9ydE9wdGlvbnMsXG4gIE9ic2lkaWFuVHJhbnNwb3J0T3B0aW9uc1xufSBmcm9tICcuL3RyYW5zcG9ydC1vcHRpb25zLm1qcyc7XG5leHBvcnQgdHlwZSB7XG4gIE9ic2lkaWFuVHJhbnNwb3J0LFxuICBUcmFuc3BvcnRFdmFsT3B0aW9uc1xufSBmcm9tICcuL3RyYW5zcG9ydC5tanMnO1xuZXhwb3J0IHtcbiAgcmVnaXN0ZXJWYXVsdCxcbiAgdW5yZWdpc3RlclZhdWx0XG59IGZyb20gJy4vdmF1bHQtcmVnaXN0cnkubWpzJztcbiJdLAogICJtYXBwaW5ncyI6ICJBQU1BLFNBQVMsaUJBQWlCO0FBRTFCLFNBQVMsc0JBQXNCO0FBQy9CLFNBQVMsaUJBQWlCO0FBRTFCLFNBQVMsdUJBQXVCO0FBRWhDLFNBQVMsMkJBQTJCO0FBQ3BDLFNBQVMsMkJBQTJCO0FBQ3BDLFNBQVMsa0NBQWtDO0FBVzNDO0FBQUEsRUFDRTtBQUFBLEVBQ0E7QUFBQSxPQUNLOyIsCiAgIm5hbWVzIjogW10KfQo=