@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/cjs/desktop-request-url-stream.cjs

@@ -0,0 +1,258 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var desktop_request_url_stream_exports = {};
+__export(desktop_request_url_stream_exports, {
+  openDesktopRequestUrlStream: () => openDesktopRequestUrlStream
+});
+module.exports = __toCommonJS(desktop_request_url_stream_exports);
+var import_abort_controller = require('@mnaoumov/typescript-lib/abort-controller');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_node_http = require('node:http');
+var import_node_https = require('node:https');
+const MAX_REDIRECT_COUNT = 20;
+const HTTP_MOVED_PERMANENTLY_STATUS = 301;
+const HTTP_FOUND_STATUS = 302;
+const HTTP_SEE_OTHER_STATUS = 303;
+const HTTP_TEMPORARY_REDIRECT_STATUS = 307;
+const HTTP_PERMANENT_REDIRECT_STATUS = 308;
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+  HTTP_FOUND_STATUS,
+  HTTP_MOVED_PERMANENTLY_STATUS,
+  HTTP_PERMANENT_REDIRECT_STATUS,
+  HTTP_SEE_OTHER_STATUS,
+  HTTP_TEMPORARY_REDIRECT_STATUS
+]);
+const BODY_HEADERS = /* @__PURE__ */ new Set(["content-length", "content-type"]);
+async function openDesktopRequestUrlStream(request) {
+  let currentRequest = {
+    abortSignal: request.abortSignal,
+    body: request.body,
+    headers: request.headers,
+    method: request.method,
+    url: request.url
+  };
+  for (let redirectCount = 0; ; redirectCount++) {
+    const incomingMessage = await sendRequest(currentRequest);
+    const status = (0, import_type_guards.ensureNonNullable)(incomingMessage.statusCode);
+    const location = incomingMessage.headers.location;
+    if (!REDIRECT_STATUSES.has(status) || location === void 0) {
+      return {
+        body: createIncomingMessageStream(incomingMessage, request.abortSignal),
+        headers: flattenHeaders(incomingMessage.headers),
+        status,
+        url: currentRequest.url
+      };
+    }
+    incomingMessage.resume();
+    if (redirectCount >= MAX_REDIRECT_COUNT) {
+      throw new TypeError(`Too many redirects requesting ${request.url}`);
+    }
+    const nextUrl = new URL(location, currentRequest.url);
+    if (nextUrl.protocol !== "http:" && nextUrl.protocol !== "https:") {
+      throw new TypeError(`Unsupported protocol ${nextUrl.protocol} in the redirect to ${nextUrl.href}`);
+    }
+    currentRequest = getRedirectedRequest(currentRequest, status, nextUrl.href);
+  }
+}
+function createIncomingMessageStream(incomingMessage, abortSignal) {
+  let isSettled = false;
+  let abortListener;
+  return new ReadableStream({
+    cancel() {
+      isSettled = true;
+      abortListener[Symbol.dispose]();
+      incomingMessage.destroy();
+    },
+    pull() {
+      incomingMessage.resume();
+    },
+    start(controller) {
+      function settle(error) {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        if (error === void 0) {
+          controller.close();
+        } else {
+          controller.error(error);
+        }
+      }
+      incomingMessage.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+        if (Number(controller.desiredSize) <= 0) {
+          incomingMessage.pause();
+        }
+      });
+      incomingMessage.on("end", () => {
+        abortListener[Symbol.dispose]();
+        settle();
+      });
+      incomingMessage.on("error", (error) => {
+        abortListener[Symbol.dispose]();
+        settle(error);
+      });
+      abortListener = (0, import_abort_controller.onAbort)(abortSignal, () => {
+        settle(abortSignal.reason);
+        incomingMessage.destroy(abortSignal.reason);
+      });
+    }
+  });
+}
+function flattenHeaders(headers) {
+  const flatHeaders = {};
+  for (const [name, value] of Object.entries(headers)) {
+    flatHeaders[name] = [value].flat().join(", ");
+  }
+  return flatHeaders;
+}
+function getRedirectedRequest(request, status, url) {
+  const shouldSwitchToGet = status === HTTP_SEE_OTHER_STATUS || request.method === "POST" && (status === HTTP_MOVED_PERMANENTLY_STATUS || status === HTTP_FOUND_STATUS);
+  if (!shouldSwitchToGet) {
+    return { ...request, url };
+  }
+  return {
+    abortSignal: request.abortSignal,
+    body: void 0,
+    headers: Object.fromEntries(Object.entries(request.headers).filter(([name]) => !BODY_HEADERS.has(name.toLowerCase()))),
+    method: "GET",
+    url
+  };
+}
+async function sendRequest(params) {
+  const request = params.url.startsWith("https:") ? import_node_https.request : import_node_http.request;
+  return await new Promise((resolve, reject) => {
+    const clientRequest = request(params.url, {
+      headers: { ...params.headers },
+      method: params.method,
+      signal: params.abortSignal
+    }, resolve);
+    clientRequest.on("error", (error) => {
+      reject(params.abortSignal.aborted ? params.abortSignal.reason : error);
+    });
+    clientRequest.end(typeof params.body === "string" ? params.body : params.body && new Uint8Array(params.body));
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDesktopRequestUrlStream
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/desktop-request-url-stream.ts"],"sourcesContent":["/**\n * @file\n *\n * The desktop arm of {@link ./request-url.ts | requestUrlStream}: requests a URL through `node:http` /\n * `node:https`, so the response body streams as it arrives and an abort really cancels the request.\n *\n * Desktop only: it reads `node:http` and `node:https`. Reach it through `requestUrlStream`, which imports it\n * dynamically on desktop.\n *\n * Unlike Chromium's network stack, Node does not read the system proxy settings or certificate store, so a machine\n * that reaches the internet only through a proxy, or that intercepts TLS with its own root certificate, needs the\n * buffered `requestUrlEx` instead.\n */\n\n/* eslint-disable n/no-unsupported-features/node-builtins -- ReadableStream is the Obsidian renderer's Web API, not a Node builtin. */\n\nimport type {\n  IncomingHttpHeaders,\n  IncomingMessage\n} from 'node:http';\n\nimport { onAbort } from '@mnaoumov/typescript-lib/abort-controller';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { request as requestHttp } from 'node:http';\nimport { request as requestHttps } from 'node:https';\n\nimport type {\n  EncodedRequestUrlRequest,\n  RequestUrlStreamResponse\n} from './request-url.ts';\n\nconst MAX_REDIRECT_COUNT = 20;\nconst HTTP_MOVED_PERMANENTLY_STATUS = 301;\nconst HTTP_FOUND_STATUS = 302;\nconst HTTP_SEE_OTHER_STATUS = 303;\nconst HTTP_TEMPORARY_REDIRECT_STATUS = 307;\nconst HTTP_PERMANENT_REDIRECT_STATUS = 308;\nconst REDIRECT_STATUSES = new Set([\n  HTTP_FOUND_STATUS,\n  HTTP_MOVED_PERMANENTLY_STATUS,\n  HTTP_PERMANENT_REDIRECT_STATUS,\n  HTTP_SEE_OTHER_STATUS,\n  HTTP_TEMPORARY_REDIRECT_STATUS\n]);\nconst BODY_HEADERS = new Set(['content-length', 'content-type']);\n\ninterface SendRequestParams {\n  readonly abortSignal: AbortSignal;\n  readonly body: ArrayBuffer | string | undefined;\n  readonly headers: Readonly<Record<string, string>>;\n  readonly method: string;\n  readonly url: string;\n}\n\n/**\n * Requests a URL through `node:http` / `node:https` and returns its body as a stream, following redirects.\n *\n * @param request - The encoded request.\n * @returns The response, with a streamed body.\n */\nexport async function openDesktopRequestUrlStream(request: EncodedRequestUrlRequest): Promise<RequestUrlStreamResponse> {\n  let currentRequest: SendRequestParams = {\n    abortSignal: request.abortSignal,\n    body: request.body,\n    headers: request.headers,\n    method: request.method,\n    url: request.url\n  };\n\n  for (let redirectCount = 0;; redirectCount++) {\n    const incomingMessage = await sendRequest(currentRequest);\n    // A response to a client request always carries its status code.\n    const status = ensureNonNullable(incomingMessage.statusCode);\n    const location = incomingMessage.headers.location;\n    if (!REDIRECT_STATUSES.has(status) || location === undefined) {\n      return {\n        body: createIncomingMessageStream(incomingMessage, request.abortSignal),\n        headers: flattenHeaders(incomingMessage.headers),\n        status,\n        url: currentRequest.url\n      };\n    }\n\n    incomingMessage.resume();\n    if (redirectCount >= MAX_REDIRECT_COUNT) {\n      throw new TypeError(`Too many redirects requesting ${request.url}`);\n    }\n    const nextUrl = new URL(location, currentRequest.url);\n    if (nextUrl.protocol !== 'http:' && nextUrl.protocol !== 'https:') {\n      throw new TypeError(`Unsupported protocol ${nextUrl.protocol} in the redirect to ${nextUrl.href}`);\n    }\n    currentRequest = getRedirectedRequest(currentRequest, status, nextUrl.href);\n  }\n}\n\nfunction createIncomingMessageStream(incomingMessage: IncomingMessage, abortSignal: AbortSignal): ReadableStream<Uint8Array> {\n  let isSettled = false;\n  // Assigned in `start`, which runs inside the constructor, so it is in place before `cancel` can run.\n  let abortListener: Disposable;\n  return new ReadableStream<Uint8Array>({\n    cancel(): void {\n      isSettled = true;\n      abortListener[Symbol.dispose]();\n      incomingMessage.destroy();\n    },\n    pull(): void {\n      incomingMessage.resume();\n    },\n    start(controller): void {\n      function settle(error?: unknown): void {\n        if (isSettled) {\n          return;\n        }\n        isSettled = true;\n        if (error === undefined) {\n          controller.close();\n        } else {\n          controller.error(error);\n        }\n      }\n\n      incomingMessage.on('data', (chunk: Buffer) => {\n        // A copy, so the chunk belongs to the renderer's realm whatever Node does with its buffer afterwards.\n        controller.enqueue(new Uint8Array(chunk));\n        if (Number(controller.desiredSize) <= 0) {\n          incomingMessage.pause();\n        }\n      });\n      incomingMessage.on('end', () => {\n        abortListener[Symbol.dispose]();\n        settle();\n      });\n      incomingMessage.on('error', (error) => {\n        abortListener[Symbol.dispose]();\n        settle(error);\n      });\n      abortListener = onAbort(abortSignal, () => {\n        settle(abortSignal.reason);\n        // The `error` event this raises finds the stream settled already.\n        incomingMessage.destroy(abortSignal.reason as Error);\n      });\n    }\n  });\n}\nfunction flattenHeaders(headers: IncomingHttpHeaders): Record<string, string> {\n  const flatHeaders: Record<string, string> = {};\n  for (const [name, value] of Object.entries(headers)) {\n    // Node joins every repeated header but `set-cookie`, which arrives as an array.\n    flatHeaders[name] = [value].flat().join(', ');\n  }\n  return flatHeaders;\n}\n\nfunction getRedirectedRequest(request: SendRequestParams, status: number, url: string): SendRequestParams {\n  // What `fetch` does: a 303, and a 301 or 302 answering a POST, become a GET without a body.\n  const shouldSwitchToGet = status === HTTP_SEE_OTHER_STATUS\n    || (request.method === 'POST' && (status === HTTP_MOVED_PERMANENTLY_STATUS || status === HTTP_FOUND_STATUS));\n  if (!shouldSwitchToGet) {\n    return { ...request, url };\n  }\n  return {\n    abortSignal: request.abortSignal,\n    body: undefined,\n    headers: Object.fromEntries(Object.entries(request.headers).filter(([name]) => !BODY_HEADERS.has(name.toLowerCase()))),\n    method: 'GET',\n    url\n  };\n}\n\nasync function sendRequest(params: SendRequestParams): Promise<IncomingMessage> {\n  const request = params.url.startsWith('https:') ? requestHttps : requestHttp;\n  return await new Promise((resolve, reject) => {\n    const clientRequest = request(params.url, {\n      headers: { ...params.headers },\n      method: params.method,\n      signal: params.abortSignal\n    }, resolve);\n    clientRequest.on('error', (error) => {\n      reject(params.abortSignal.aborted ? params.abortSignal.reason as Error : error);\n    });\n    clientRequest.end(typeof params.body === 'string' ? params.body : params.body && new Uint8Array(params.body));\n  });\n}\n/* eslint-enable n/no-unsupported-features/node-builtins -- ReadableStream is the Obsidian renderer's Web API, not a Node builtin. */\n"],"mappings":"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","names":["requestHttps","requestHttp"]}

package/dist/lib/cjs/desktop-request-url-stream.d.cts

@@ -0,0 +1,22 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * The desktop arm of {@link ./request-url.ts | requestUrlStream}: requests a URL through `node:http` /
+ * `node:https`, so the response body streams as it arrives and an abort really cancels the request.
+ *
+ * Desktop only: it reads `node:http` and `node:https`. Reach it through `requestUrlStream`, which imports it
+ * dynamically on desktop.
+ *
+ * Unlike Chromium's network stack, Node does not read the system proxy settings or certificate store, so a machine
+ * that reaches the internet only through a proxy, or that intercepts TLS with its own root certificate, needs the
+ * buffered `requestUrlEx` instead.
+ */
+import type { EncodedRequestUrlRequest, RequestUrlStreamResponse } from './request-url.cjs';
+/**
+ * Requests a URL through `node:http` / `node:https` and returns its body as a stream, following redirects.
+ *
+ * @param request - The encoded request.
+ * @returns The response, with a streamed body.
+ */
+export declare function openDesktopRequestUrlStream(request: EncodedRequestUrlRequest): Promise<RequestUrlStreamResponse>;

package/dist/lib/cjs/editor-suggest-registrar.cjs

@@ -118,6 +118,7 @@ __export(editor_suggest_registrar_exports, {
 });
 module.exports = __toCommonJS(editor_suggest_registrar_exports);
 var import_obsidian = require('obsidian');
+var import_editor_suggest = require('./editor-suggest.cjs');
 class PluginEditorSuggestRegistrar {
   /**
    * Creates a new instance of the {@link PluginEditorSuggestRegistrar} class.
@@ -132,13 +133,18 @@ class PluginEditorSuggestRegistrar {
    * Registers an editor suggest.
    *
    * @param editorSuggest - The editor suggest to register.
+   * @param options - The options.
    */
-  registerEditorSuggest(editorSuggest) {
+  // eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- It implements `EditorSuggestRegistrar.registerEditorSuggest`, whose options type every registrar shares.
+  registerEditorSuggest(editorSuggest, options) {
     this.plugin.registerEditorSuggest(editorSuggest);
+    if (options?.shouldPrioritize) {
+      (0, import_editor_suggest.prioritizeEditorSuggest)({ app: this.plugin.app, editorSuggest });
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PluginEditorSuggestRegistrar
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lZGl0b3Itc3VnZ2VzdC1yZWdpc3RyYXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEVkaXRvciBzdWdnZXN0IHJlZ2lzdHJhcnMuXG4gKi9cblxuaW1wb3J0IHtcbiAgRWRpdG9yU3VnZ2VzdCxcbiAgUGx1Z2luXG59IGZyb20gJ29ic2lkaWFuJztcblxuLyoqXG4gKiBFZGl0b3Igc3VnZ2VzdCByZWdpc3RyYXIuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRWRpdG9yU3VnZ2VzdFJlZ2lzdHJhciB7XG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgYW4gZWRpdG9yIHN1Z2dlc3QuXG4gICAqXG4gICAqIEBwYXJhbSBlZGl0b3JTdWdnZXN0IC0gVGhlIGVkaXRvciBzdWdnZXN0IHRvIHJlZ2lzdGVyLlxuICAgKi9cbiAgcmVhZG9ubHkgcmVnaXN0ZXJFZGl0b3JTdWdnZXN0OiAoZWRpdG9yU3VnZ2VzdDogRWRpdG9yU3VnZ2VzdDx1bmtub3duPikgPT4gdm9pZDtcbn1cblxuLyoqXG4gKiBFZGl0b3Igc3VnZ2VzdCByZWdpc3RyYXIgaW4gYW4gT2JzaWRpYW4gcGx1Z2luLlxuICovXG5leHBvcnQgY2xhc3MgUGx1Z2luRWRpdG9yU3VnZ2VzdFJlZ2lzdHJhciBpbXBsZW1lbnRzIEVkaXRvclN1Z2dlc3RSZWdpc3RyYXIge1xuICAvKipcbiAgICogQ3JlYXRlcyBhIG5ldyBpbnN0YW5jZSBvZiB0aGUge0BsaW5rIFBsdWdpbkVkaXRvclN1Z2dlc3RSZWdpc3RyYXJ9IGNsYXNzLlxuICAgKlxuICAgKiBAcGFyYW0gcGx1Z2luIC0gVGhlIE9ic2lkaWFuIHBsdWdpbiBpbnN0YW5jZS5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgcmVhZG9ubHkgcGx1Z2luOiBQbHVnaW4pIHt9XG5cbiAgLyoqXG4gICAqIFJlZ2lzdGVycyBhbiBlZGl0b3Igc3VnZ2VzdC5cbiAgICpcbiAgICogQHBhcmFtIGVkaXRvclN1Z2dlc3QgLSBUaGUgZWRpdG9yIHN1Z2dlc3QgdG8gcmVnaXN0ZXIuXG4gICAqL1xuICBwdWJsaWMgcmVnaXN0ZXJFZGl0b3JTdWdnZXN0KGVkaXRvclN1Z2dlc3Q6IEVkaXRvclN1Z2dlc3Q8dW5rbm93bj4pOiB2b2lkIHtcbiAgICB0aGlzLnBsdWdpbi5yZWdpc3RlckVkaXRvclN1Z2dlc3QoZWRpdG9yU3VnZ2VzdCk7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQU1BLHNCQUdPO0FBaUJBLE1BQU0sNkJBQStEO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBTW5FLFlBQStCLFFBQWdCO0FBQWhCO0FBQUEsRUFBaUI7QUFBQSxFQUFqQjtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU8vQixzQkFBc0IsZUFBNkM7QUFDeEUsU0FBSyxPQUFPLHNCQUFzQixhQUFhO0FBQUEsRUFDakQ7QUFDRjsiLCJuYW1lcyI6W119
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/editor-suggest-registrar.d.cts

@@ -13,8 +13,19 @@ export interface EditorSuggestRegistrar {
      * Registers an editor suggest.
      *
      * @param editorSuggest - The editor suggest to register.
+     * @param options - The options.
      */
-    readonly registerEditorSuggest: (editorSuggest: EditorSuggest<unknown>) => void;
+    readonly registerEditorSuggest: (editorSuggest: EditorSuggest<unknown>, options?: RegisterEditorSuggestOptions) => void;
+}
+/**
+ * Options for {@link EditorSuggestRegistrar.registerEditorSuggest}.
+ */
+export interface RegisterEditorSuggestOptions {
+    /**
+     * Whether the suggest is asked before the others already registered, Obsidian's own included. Defaults to `false`:
+     * registration order decides.
+     */
+    readonly shouldPrioritize?: boolean;
 }
 /**
  * Editor suggest registrar in an Obsidian plugin.
@@ -31,6 +42,7 @@ export declare class PluginEditorSuggestRegistrar implements EditorSuggestRegist
      * Registers an editor suggest.
      *
      * @param editorSuggest - The editor suggest to register.
+     * @param options - The options.
      */
-    registerEditorSuggest(editorSuggest: EditorSuggest<unknown>): void;
+    registerEditorSuggest(editorSuggest: EditorSuggest<unknown>, options?: RegisterEditorSuggestOptions): void;
 }

package/dist/lib/cjs/editor-suggest.cjs

@@ -0,0 +1,197 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editor_suggest_exports = {};
+__export(editor_suggest_exports, {
+  CommandEditorSuggest: () => CommandEditorSuggest,
+  prioritizeEditorSuggest: () => prioritizeEditorSuggest
+});
+module.exports = __toCommonJS(editor_suggest_exports);
+var import_obsidian = require('obsidian');
+class CommandEditorSuggest extends import_obsidian.EditorSuggest {
+  commandStart = null;
+  /**
+   * Closes the suggest, ending a command-opened session.
+   */
+  close() {
+    this.commandStart = null;
+    super.close();
+  }
+  /**
+   * Decides whether the suggest opens. While a command-opened session lasts, the query is the text from where it was
+   * opened to the cursor; otherwise {@link CommandEditorSuggest.onTextTrigger} decides.
+   *
+   * @param cursor - The cursor.
+   * @param editor - The editor.
+   * @param file - The file open in the editor.
+   * @returns The trigger info, or `null` to stay closed.
+   */
+  onTrigger(cursor, editor, file) {
+    const start = this.commandStart;
+    if (start) {
+      if (cursor.line === start.line && cursor.ch >= start.ch) {
+        return {
+          end: cursor,
+          query: editor.getLine(cursor.line).slice(start.ch, cursor.ch),
+          start
+        };
+      }
+      this.commandStart = null;
+    }
+    return this.onTextTrigger(cursor, editor, file);
+  }
+  /**
+   * Opens the suggest at the cursor of an editor, typically from a command's `editorCallback`.
+   *
+   * @param params - The parameters.
+   * @returns Whether the suggest accepted the cursor: `false` when text is selected.
+   */
+  openFromCommand(params) {
+    const { editor, file } = params;
+    this.commandStart = editor.getCursor();
+    if (!this.trigger(editor, file, true)) {
+      this.commandStart = null;
+      return false;
+    }
+    this.app.workspace.editorSuggest.setCurrentSuggest(this);
+    return true;
+  }
+  /**
+   * Decides whether the suggest opens on typed text, outside a command-opened session. Never, by default.
+   *
+   * @param _cursor - The cursor.
+   * @param _editor - The editor.
+   * @param _file - The file open in the editor.
+   * @returns The trigger info, or `null` to stay closed.
+   */
+  onTextTrigger(_cursor, _editor, _file) {
+    return null;
+  }
+}
+function prioritizeEditorSuggest(params) {
+  const { app, editorSuggest } = params;
+  const suggests = app.workspace.editorSuggest.suggests;
+  const index = suggests.indexOf(editorSuggest);
+  if (index === -1) {
+    throw new Error("The editor suggest is not registered. Register it before prioritizing it.");
+  }
+  suggests.splice(index, 1);
+  suggests.unshift(editorSuggest);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandEditorSuggest,
+  prioritizeEditorSuggest
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/editor-suggest.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for `EditorSuggest`: giving one priority over the others, and opening one from a command.\n *\n * Read from Obsidian `1.15.0`: the editor asks each suggest in `app.workspace.editorSuggest.suggests` in order, and the\n * first whose `trigger` accepts the cursor wins, so registration order decides which suggest opens. A suggest shows its\n * list only when the trigger is explicit (the user typed) or it is already open.\n */\n\nimport type {\n  App,\n  Editor,\n  EditorPosition,\n  EditorSuggestTriggerInfo,\n  TFile\n} from 'obsidian';\n\nimport { EditorSuggest } from 'obsidian';\n\n/**\n * Parameters for {@link CommandEditorSuggest.openFromCommand}.\n */\nexport interface CommandEditorSuggestOpenFromCommandParams {\n  /**\n   * The editor to open the suggest in.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The file open in the editor.\n   */\n  readonly file: null | TFile;\n}\n\n/**\n * Parameters for {@link prioritizeEditorSuggest}.\n */\nexport interface PrioritizeEditorSuggestParams {\n  /**\n   * The Obsidian app.\n   */\n  readonly app: App;\n\n  /**\n   * The registered editor suggest.\n   */\n  readonly editorSuggest: EditorSuggest<unknown>;\n}\n\n/**\n * An editor suggest that a command can open at the cursor, without a trigger character.\n *\n * {@link CommandEditorSuggest.openFromCommand} opens it at the cursor; the text typed after that point, on the same\n * line, is the query, and moving the cursor before that point or off the line closes it. A subclass may still open on\n * typed text by overriding {@link CommandEditorSuggest.onTextTrigger}.\n *\n * Register it as usual, so the editor keeps it updated while the user types:\n *\n * ```ts\n * const suggest = new EmojiSuggest(this.app);\n * this.registerEditorSuggest(suggest);\n * this.addCommand({\n *   editorCallback: (editor, ctx) => {\n *     suggest.openFromCommand({ editor, file: ctx.file });\n *   },\n *   id: 'insert-emoji',\n *   name: 'Insert emoji'\n * });\n * ```\n *\n * @typeParam T - The type of a suggestion.\n */\nexport abstract class CommandEditorSuggest<T> extends EditorSuggest<T> {\n  private commandStart: EditorPosition | null = null;\n\n  /**\n   * Closes the suggest, ending a command-opened session.\n   */\n  public override close(): void {\n    this.commandStart = null;\n    super.close();\n  }\n\n  /**\n   * Decides whether the suggest opens. While a command-opened session lasts, the query is the text from where it was\n   * opened to the cursor; otherwise {@link CommandEditorSuggest.onTextTrigger} decides.\n   *\n   * @param cursor - The cursor.\n   * @param editor - The editor.\n   * @param file - The file open in the editor.\n   * @returns The trigger info, or `null` to stay closed.\n   */\n  public override onTrigger(cursor: EditorPosition, editor: Editor, file: null | TFile): EditorSuggestTriggerInfo | null {\n    const start = this.commandStart;\n    if (start) {\n      if (cursor.line === start.line && cursor.ch >= start.ch) {\n        return {\n          end: cursor,\n          query: editor.getLine(cursor.line).slice(start.ch, cursor.ch),\n          start\n        };\n      }\n      this.commandStart = null;\n    }\n    return this.onTextTrigger(cursor, editor, file);\n  }\n\n  /**\n   * Opens the suggest at the cursor of an editor, typically from a command's `editorCallback`.\n   *\n   * @param params - The parameters.\n   * @returns Whether the suggest accepted the cursor: `false` when text is selected.\n   */\n  public openFromCommand(params: CommandEditorSuggestOpenFromCommandParams): boolean {\n    const { editor, file } = params;\n    this.commandStart = editor.getCursor();\n    if (!this.trigger(editor, file, true)) {\n      this.commandStart = null;\n      return false;\n    }\n    this.app.workspace.editorSuggest.setCurrentSuggest(this);\n    return true;\n  }\n\n  /**\n   * Decides whether the suggest opens on typed text, outside a command-opened session. Never, by default.\n   *\n   * @param _cursor - The cursor.\n   * @param _editor - The editor.\n   * @param _file - The file open in the editor.\n   * @returns The trigger info, or `null` to stay closed.\n   */\n  protected onTextTrigger(_cursor: EditorPosition, _editor: Editor, _file: null | TFile): EditorSuggestTriggerInfo | null {\n    return null;\n  }\n}\n\n/**\n * Moves a registered editor suggest to the front of the list the editor asks, so it opens ahead of every other suggest\n * whose trigger accepts the same text, Obsidian's own `[[` and `#` suggests included. A suggest prioritized later goes\n * ahead of it in turn.\n *\n * @param params - The parameters.\n * @throws If the editor suggest is not registered.\n */\nexport function prioritizeEditorSuggest(params: PrioritizeEditorSuggestParams): void {\n  const { app, editorSuggest } = params;\n  const suggests = app.workspace.editorSuggest.suggests;\n  const index = suggests.indexOf(editorSuggest);\n  if (index === -1) {\n    throw new Error('The editor suggest is not registered. Register it before prioritizing it.');\n  }\n  suggests.splice(index, 1);\n  suggests.unshift(editorSuggest);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,sBAA8B;AAuDvB,MAAe,6BAAgC,8BAAiB;AAAA,EAC7D,eAAsC;AAAA;AAAA;AAAA;AAAA,EAK9B,QAAc;AAC5B,SAAK,eAAe;AACpB,UAAM,MAAM;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWgB,UAAU,QAAwB,QAAgB,MAAqD;AACrH,UAAM,QAAQ,KAAK;AACnB,QAAI,OAAO;AACT,UAAI,OAAO,SAAS,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI;AACvD,eAAO;AAAA,UACL,KAAK;AAAA,UACL,OAAO,OAAO,QAAQ,OAAO,IAAI,EAAE,MAAM,MAAM,IAAI,OAAO,EAAE;AAAA,UAC5D;AAAA,QACF;AAAA,MACF;AACA,WAAK,eAAe;AAAA,IACtB;AACA,WAAO,KAAK,cAAc,QAAQ,QAAQ,IAAI;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,gBAAgB,QAA4D;AACjF,UAAM,EAAE,QAAQ,KAAK,IAAI;AACzB,SAAK,eAAe,OAAO,UAAU;AACrC,QAAI,CAAC,KAAK,QAAQ,QAAQ,MAAM,IAAI,GAAG;AACrC,WAAK,eAAe;AACpB,aAAO;AAAA,IACT;AACA,SAAK,IAAI,UAAU,cAAc,kBAAkB,IAAI;AACvD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUU,cAAc,SAAyB,SAAiB,OAAsD;AACtH,WAAO;AAAA,EACT;AACF;AAUO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,EAAE,KAAK,cAAc,IAAI;AAC/B,QAAM,WAAW,IAAI,UAAU,cAAc;AAC7C,QAAM,QAAQ,SAAS,QAAQ,aAAa;AAC5C,MAAI,UAAU,IAAI;AAChB,UAAM,IAAI,MAAM,2EAA2E;AAAA,EAC7F;AACA,WAAS,OAAO,OAAO,CAAC;AACxB,WAAS,QAAQ,aAAa;AAChC;","names":[]}