obsidian-dev-utils 101.4.1 → 101.6.0

package/dist/lib/cjs/obsidian/modals/select-item.d.cts

@@ -7,6 +7,7 @@
  * This module exports a function to display a modal that allows the user to select an item from a list. The modal uses fuzzy search to help the user find the item.
  */
 import type { ModalParamsBase } from './modal.cjs';
+import { SpellcheckMode } from '../obsidian-settings.cjs';
 /**
  * Options for {@link selectItem}.
  *
@@ -30,6 +31,19 @@ export interface SelectItemParams<T> extends ModalParamsBase {
      * @default `''`
      */
     readonly placeholder?: string;
+    /**
+     * The mode deciding whether the search box is spell-checked.
+     *
+     * The default is what this modal has always done, so passing nothing changes nothing. It differs from
+     * the `prompt()` parameter's default on purpose: Obsidian builds every `SuggestModal` input
+     * with a hardcoded `spellcheck="false"` and never consults `Editor > Spellcheck` there, so `Off` — not
+     * `FollowObsidianSetting` — is the value that leaves the box exactly as Obsidian built it.
+     *
+     * Raise it for a picker whose box can NAME the thing it is about to create, rather than only find one.
+     *
+     * @default `SpellcheckMode.Off`
+     */
+    readonly spellcheckMode?: SpellcheckMode;
 }
 /**
  * Displays a selection modal in Obsidian for choosing an item from a list.

package/dist/lib/cjs/obsidian/obsidian-settings.cjs

@@ -142,24 +142,51 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var obsidian_settings_exports = {};
 __export(obsidian_settings_exports, {
+  SpellcheckMode: () => SpellcheckMode,
   getNewLinkFormat: () => getNewLinkFormat,
   isSpellcheckEnabled: () => isSpellcheckEnabled,
+  isSpellcheckEnabledForMode: () => isSpellcheckEnabledForMode,
   shouldUseWikilinks: () => shouldUseWikilinks
 });
 module.exports = __toCommonJS(obsidian_settings_exports);
+var import_type_guards = require('../type-guards.cjs');
+var SpellcheckMode = /* @__PURE__ */ ((SpellcheckMode2) => {
+  SpellcheckMode2["AlwaysOn"] = "AlwaysOn";
+  SpellcheckMode2["FollowObsidianSetting"] = "FollowObsidianSetting";
+  SpellcheckMode2["Off"] = "Off";
+  return SpellcheckMode2;
+})(SpellcheckMode || {});
 function getNewLinkFormat(app) {
   return app.vault.getConfig("newLinkFormat");
 }
 function isSpellcheckEnabled(app) {
   return Boolean(app.vault.getConfig("spellcheck"));
 }
+function isSpellcheckEnabledForMode(app, spellcheckMode) {
+  switch (spellcheckMode) {
+    case "AlwaysOn" /* AlwaysOn */: {
+      return true;
+    }
+    case "FollowObsidianSetting" /* FollowObsidianSetting */: {
+      return isSpellcheckEnabled(app);
+    }
+    case "Off" /* Off */: {
+      return false;
+    }
+    default: {
+      (0, import_type_guards.assertNever)(spellcheckMode);
+    }
+  }
+}
 function shouldUseWikilinks(app) {
   return !app.vault.getConfig("useMarkdownLinks");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  SpellcheckMode,
   getNewLinkFormat,
   isSpellcheckEnabled,
+  isSpellcheckEnabledForMode,
   shouldUseWikilinks
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/obsidian-settings.d.cts

@@ -5,6 +5,28 @@
  * This module provides utility functions for working with Obsidian settings.
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * A way an input decides whether it is spell-checked.
+ *
+ * The `spellcheck` attribute is the whole mechanism: Obsidian never calls Electron's
+ * `setSpellCheckerEnabled`, it only sets the attribute per element. So `AlwaysOn` really does spell-check
+ * with `Editor > Spellcheck` off, and what it invokes is Chromium's built-in checker.
+ */
+export declare enum SpellcheckMode {
+    /**
+     * Always spell-check the input, whatever `Editor > Spellcheck` says.
+     */
+    AlwaysOn = "AlwaysOn",
+    /**
+     * Follow `Editor > Spellcheck`, the way Obsidian's own name-entry surfaces do — the inline note title,
+     * the file explorer's inline rename, the properties fields.
+     */
+    FollowObsidianSetting = "FollowObsidianSetting",
+    /**
+     * Never spell-check the input, whatever `Editor > Spellcheck` says.
+     */
+    Off = "Off"
+}
 /**
  * A format of the new link.
  */
@@ -23,6 +45,14 @@ export declare function getNewLinkFormat(app: App): NewLinkFormat;
  * @returns Whether the spellcheck is enabled.
  */
 export declare function isSpellcheckEnabled(app: App): boolean;
+/**
+ * Resolves a {@link SpellcheckMode} against the Obsidian settings.
+ *
+ * @param app - The Obsidian app instance.
+ * @param spellcheckMode - The mode to resolve.
+ * @returns Whether the input should be spell-checked.
+ */
+export declare function isSpellcheckEnabledForMode(app: App, spellcheckMode: SpellcheckMode): boolean;
 /**
  * Retrieves whether to use wikilinks based on the Obsidian settings.
  *

package/dist/lib/cjs/obsidian/plugin/index.cjs

@@ -157,7 +157,8 @@ __export(plugin_exports, {
   "plugin-api": () => plugin_api,
   "plugin-context": () => plugin_context,
   "plugin-event-source": () => plugin_event_source,
-  "plugin-settings-tab": () => plugin_settings_tab
+  "plugin-settings-tab": () => plugin_settings_tab,
+  "settings-migration-api": () => settings_migration_api
 });
 module.exports = __toCommonJS(plugin_exports);
 var obsidian_plugin_repo_paths = __toESM(__extractDefault(require('./obsidian-plugin-repo-paths.cjs')), 1);
@@ -166,6 +167,7 @@ var plugin_context = __toESM(__extractDefault(require('./plugin-context.cjs')),
 var plugin_event_source = __toESM(__extractDefault(require('./plugin-event-source.cjs')), 1);
 var plugin_settings_tab = __toESM(__extractDefault(require('./plugin-settings-tab.cjs')), 1);
 var plugin = __toESM(__extractDefault(require('./plugin.cjs')), 1);
+var settings_migration_api = __toESM(__extractDefault(require('./settings-migration-api.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "obsidian-plugin-repo-paths": null,
@@ -173,6 +175,7 @@ var plugin = __toESM(__extractDefault(require('./plugin.cjs')), 1);
   "plugin-api": null,
   "plugin-context": null,
   "plugin-event-source": null,
-  "plugin-settings-tab": null
+  "plugin-settings-tab": null,
+  "settings-migration-api": null
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdvYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocycgZnJvbSAnLi9vYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocy50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWFwaScgZnJvbSAnLi9wbHVnaW4tYXBpLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tc2V0dGluZ3MtdGFiJyBmcm9tICcuL3BsdWdpbi1zZXR0aW5ncy10YWIudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbicgZnJvbSAnLi9wbHVnaW4udHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUEsc0NBQUFBO0FBQUEsRUFBQTtBQUFBLHNCQUFBQztBQUFBLEVBQUEsd0JBQUFDO0FBQUEsRUFBQSw2QkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBO0FBQUE7QUFFQSxJQUFBSiw2QkFBOEM7QUFDOUMsSUFBQUMsYUFBOEI7QUFDOUIsSUFBQUMsaUJBQWtDO0FBQ2xDLElBQUFDLHNCQUF1QztBQUN2QyxJQUFBQyxzQkFBdUM7QUFDdkMsYUFBMEI7IiwKICAibmFtZXMiOiBbIm9ic2lkaWFuLXBsdWdpbi1yZXBvLXBhdGhzIiwgInBsdWdpbi1hcGkiLCAicGx1Z2luLWNvbnRleHQiLCAicGx1Z2luLWV2ZW50LXNvdXJjZSIsICJwbHVnaW4tc2V0dGluZ3MtdGFiIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdvYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocycgZnJvbSAnLi9vYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocy50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWFwaScgZnJvbSAnLi9wbHVnaW4tYXBpLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tc2V0dGluZ3MtdGFiJyBmcm9tICcuL3BsdWdpbi1zZXR0aW5ncy10YWIudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbicgZnJvbSAnLi9wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ3NldHRpbmdzLW1pZ3JhdGlvbi1hcGknIGZyb20gJy4vc2V0dGluZ3MtbWlncmF0aW9uLWFwaS50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQSxzQ0FBQUE7QUFBQSxFQUFBO0FBQUEsc0JBQUFDO0FBQUEsRUFBQSx3QkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBLEVBQUEsNkJBQUFDO0FBQUEsRUFBQSxnQ0FBQUM7QUFBQTtBQUFBO0FBRUEsSUFBQUwsNkJBQThDO0FBQzlDLElBQUFDLGFBQThCO0FBQzlCLElBQUFDLGlCQUFrQztBQUNsQyxJQUFBQyxzQkFBdUM7QUFDdkMsSUFBQUMsc0JBQXVDO0FBQ3ZDLGFBQTBCO0FBQzFCLElBQUFDLHlCQUEwQzsiLAogICJuYW1lcyI6IFsib2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMiLCAicGx1Z2luLWFwaSIsICJwbHVnaW4tY29udGV4dCIsICJwbHVnaW4tZXZlbnQtc291cmNlIiwgInBsdWdpbi1zZXR0aW5ncy10YWIiLCAic2V0dGluZ3MtbWlncmF0aW9uLWFwaSJdCn0K

package/dist/lib/cjs/obsidian/plugin/index.d.cts

@@ -5,3 +5,4 @@ export * as 'plugin-context' from './plugin-context.cjs';
 export * as 'plugin-event-source' from './plugin-event-source.cjs';
 export * as 'plugin-settings-tab' from './plugin-settings-tab.cjs';
 export * as 'plugin' from './plugin.cjs';
+export * as 'settings-migration-api' from './settings-migration-api.cjs';

package/dist/lib/cjs/obsidian/plugin/settings-migration-api.cjs

@@ -0,0 +1,141 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= keepName;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 __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 settings_migration_api_exports = {};
+module.exports = __toCommonJS(settings_migration_api_exports);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/plugin/settings-migration-api.d.cts

@@ -0,0 +1,91 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @file
+ *
+ * The generic half of a settings HANDOVER contract: one plugin offers another the settings it used to own,
+ * and the plugin that owns them now decides what to do with the offer.
+ *
+ * The shape below is deliberately the *envelope* and nothing else. A handover has three parts, and only one
+ * of them is generic:
+ *
+ * - The **envelope** — a `migrateSettings` call, who is proposing, and whether the user applied it. Identical
+ *   for every pair of plugins, so it lives here.
+ * - The **payload** — which settings are being proposed. Entirely the pair's own business, so it stays a type
+ *   parameter and is never named here.
+ * - The **provider's identity** — its plugin id and display name. Also the pair's own business, and not
+ *   something this library has any standing to own.
+ *
+ * Why it is declared rather than imported. A provider is typically an Obsidian *plugin* repo, not an npm
+ * package, so a consumer has nothing to depend on and hand-writes its own copy of the contract. Five copies
+ * of one contract with no compiler link between them means drift is SILENT — every copy still compiles and
+ * the handover fails at runtime instead. Declaring the envelope here gives both ends one declaration to
+ * compile against; `watchPluginApi` still negotiates the version at runtime, because the two ends ship
+ * independently and always will.
+ *
+ * The provider publishes it:
+ *
+ * ```ts
+ * publishPluginApi<SettingsMigrationApi<MyMigratableSettings>>({
+ *   api: this.settingsMigrationApi,
+ *   apiVersion: '1.0.0',
+ *   contract: { migrateSettings: {} },
+ *   plugin: this
+ * });
+ * ```
+ *
+ * The consumer reaches it through {@link obsidian/components/settings-migration-component!SettingsMigrationComponent},
+ * which owns the whole offer-and-retire dance.
+ */
+/**
+ * Parameters for {@link SettingsMigrationApi.migrateSettings}.
+ *
+ * @typeParam TMigratableSettings - The settings the proposing plugin may hand over.
+ */
+export interface MigrateSettingsParams<TMigratableSettings extends object> {
+    /**
+     * The values the proposing plugin offers.
+     *
+     * Conventionally every member is optional, so a plugin proposes only what it actually held and a value the
+     * provider already owns is never overwritten by a default nobody chose. That convention belongs to the pair,
+     * though — this type imposes only the envelope.
+     */
+    readonly proposedSettings: TMigratableSettings;
+    /**
+     * The `manifest.id` of the plugin making the proposal, so the provider's dialog can say whose settings
+     * these are.
+     */
+    readonly sourcePluginId: string;
+}
+/**
+ * The outcome of {@link SettingsMigrationApi.migrateSettings}.
+ */
+export interface MigrateSettingsResult {
+    /**
+     * Whether the user approved the migration.
+     *
+     * `false` means they cancelled and nothing was written, so the proposing plugin must NOT record the
+     * migration as done — a cancel is not an answer, and the offer has to come back.
+     */
+    readonly isApplied: boolean;
+}
+/**
+ * The API a plugin publishes when it is willing to receive settings another plugin used to own.
+ *
+ * @typeParam TMigratableSettings - The settings this provider accepts.
+ *
+ * @remarks
+ * The provider owns the settings, so it owns the dialog: a proposing plugin never writes into another
+ * plugin's `data.json`. It proposes, and the user approves, edits or declines.
+ */
+export interface SettingsMigrationApi<TMigratableSettings extends object> {
+    /**
+     * Offers the user a set of settings values another plugin proposes, and applies what they approve.
+     *
+     * Resolves only once the dialog is closed, so the caller learns whether the migration actually happened and
+     * can retire — or withhold — its own pending values on that answer.
+     *
+     * @param params - The proposal.
+     * @returns What the user approved.
+     */
+    migrateSettings(params: MigrateSettingsParams<TMigratableSettings>): Promise<MigrateSettingsResult>;
+}

package/dist/lib/cjs/script-utils/gate.cjs

@@ -0,0 +1,195 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= keepName;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 gate_exports = {};
+__export(gate_exports, {
+  gate: () => gate,
+  parseGateArguments: () => parseGateArguments
+});
+module.exports = __toCommonJS(gate_exports);
+var import_node_util = require('node:util');
+var import_npm_run = require('./npm-run.cjs');
+async function gate(options = {}) {
+  const {
+    shouldBuild = true,
+    shouldRunChecks = true,
+    shouldRunIntegrationTests = false
+  } = options;
+  if (shouldRunChecks) {
+    await (0, import_npm_run.npmRun)("format:check");
+    await (0, import_npm_run.npmRun)("spellcheck");
+    await (0, import_npm_run.npmRun)("lint:md");
+  }
+  if (shouldBuild) {
+    await (0, import_npm_run.npmRun)("build");
+  }
+  if (shouldRunChecks) {
+    await (0, import_npm_run.npmRun)("lint");
+    await (0, import_npm_run.npmRunOptional)("find-overexposed");
+    if (await (0, import_npm_run.npmRunOptional)("test:coverage") === import_npm_run.NpmRunOptionalResult.Skipped) {
+      await (0, import_npm_run.npmRunOptional)("test");
+    }
+    if (shouldRunIntegrationTests) {
+      await (0, import_npm_run.npmRunOptional)("test:integration");
+    }
+  }
+}
+function parseGateArguments($arguments) {
+  const { values } = (0, import_node_util.parseArgs)({
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.
+    args: $arguments,
+    options: {
+      "no-build": { type: "boolean" },
+      "no-checks": { type: "boolean" }
+    }
+  });
+  return {
+    shouldBuild: !(values["no-build"] ?? false),
+    shouldRunChecks: !(values["no-checks"] ?? false)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gate,
+  parseGateArguments
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/gate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The branch gate: the verification sequence that `updateVersion` runs as its release preflight, available\n * as a command of its own.\n *\n * Four of the preflight's checks \u2014 `format:check`, `spellcheck`, `find-overexposed` and `test:coverage` \u2014\n * are reachable by no other routine command. So the natural branch gate (build, lint, test) can be green\n * while the release is still going to fail, and the failure arrives at release time rather than in seconds\n * on the branch.\n *\n * This module exists so the two are the same code rather than two lists that agree today: `updateVersion`\n * calls {@link gate}, and a check added here is reachable from both. What the gate deliberately leaves to\n * the release path is the clean-repo assertion \u2014 a branch gate is run on a dirty tree, which is the whole\n * point of running it before committing \u2014 and the integration suite, which has to run in sequence across\n * the whole fleet and so cannot be part of a command run casually.\n *\n * The tests run ONCE, through `test:coverage` where the project defines it and through `test` otherwise.\n * Running both, as this did until 2026-09-05, was a duplicate everywhere it mattered: a project scopes its\n * two test scripts to the same vitest projects \u2014 every repo in this workspace passes the same `projects`\n * array to both \u2014 so `test:coverage` is `test` plus the threshold flags, over the identical files. It buys\n * no fail-fast either, because the coverage run fails on exactly the failures the plain run would have\n * caught. The one thing lost is the ability to switch off only the coverage half: `TEST_COVERAGE=0` now\n * turns off the gate's whole test step rather than demoting it to `test`.\n */\n\nimport { parseArgs } from 'node:util';\n\nimport {\n  npmRun,\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\n\n/**\n * Options for {@link gate}.\n */\nexport interface GateOptions {\n  /**\n   * Whether to run the build. The build is not a verification check \u2014 it is kept in the gate because it is\n   * the only step that type-checks the project, and a green lint is not a type-check.\n   *\n   * @default `true`\n   */\n  readonly shouldBuild?: boolean;\n\n  /**\n   * Whether to run the verification checks. When `false`, only the build runs, which is what\n   * `npm run version -- --no-checks` does.\n   *\n   * @default `true`\n   */\n  readonly shouldRunChecks?: boolean;\n\n  /**\n   * Whether to run the integration test suite. Off by default: integration runs have to be serialized\n   * across the whole set of sibling repositories, so a gate that always ran them would collide with\n   * another session's run.\n   *\n   * @default `false`\n   */\n  readonly shouldRunIntegrationTests?: boolean;\n}\n\n/**\n * Runs the verification sequence that `npm run version` runs as its preflight.\n *\n * The order is deliberate: the checks that finish in seconds (`format:check`, `spellcheck`, `lint:md`) run\n * first, so a typo fails the gate immediately instead of after the coverage run. Each step is dispatched\n * through the package manager, so a project overriding one of these scripts gets its own version, and each\n * step carries its own environment off switch.\n *\n * The steps that are run with {@link npmRunOptional} are skipped when the project does not define them; the\n * rest are required. The test step is the one place that reads that skip: `test:coverage` is preferred, and\n * `test` runs only as its fallback, so the suite is never run twice. The unit tests stay ahead of\n * `test:integration` for the same fastest-first reason \u2014 a broken unit test should fail before an\n * integration suite is started, not after.\n *\n * @param options - The {@link GateOptions} controlling which steps run.\n * @returns A {@link Promise} that resolves when every step has passed.\n */\nexport async function gate(options: GateOptions = {}): Promise<void> {\n  const {\n    shouldBuild = true,\n    shouldRunChecks = true,\n    shouldRunIntegrationTests = false\n  } = options;\n\n  if (shouldRunChecks) {\n    await npmRun('format:check');\n    await npmRun('spellcheck');\n    await npmRun('lint:md');\n  }\n\n  if (shouldBuild) {\n    await npmRun('build');\n  }\n\n  if (shouldRunChecks) {\n    await npmRun('lint');\n    await npmRunOptional('find-overexposed');\n\n    if (await npmRunOptional('test:coverage') === NpmRunOptionalResult.Skipped) {\n      await npmRunOptional('test');\n    }\n\n    if (shouldRunIntegrationTests) {\n      await npmRunOptional('test:integration');\n    }\n  }\n}\n\n/**\n * Parses the command-line arguments for the gate script.\n *\n * @param $arguments - The command-line arguments to parse.\n * @returns The parsed {@link GateOptions}.\n */\nexport function parseGateArguments($arguments: string[]): GateOptions {\n  const { values } = parseArgs({\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.\n    args: $arguments,\n    options: {\n      'no-build': { type: 'boolean' },\n      'no-checks': { type: 'boolean' }\n    }\n  });\n\n  return {\n    shouldBuild: !(values['no-build'] ?? false),\n    shouldRunChecks: !(values['no-checks'] ?? false)\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,uBAA0B;AAE1B,qBAIO;AAiDP,eAAsB,KAAK,UAAuB,CAAC,GAAkB;AACnE,QAAM;AAAA,IACJ,cAAc;AAAA,IACd,kBAAkB;AAAA,IAClB,4BAA4B;AAAA,EAC9B,IAAI;AAEJ,MAAI,iBAAiB;AACnB,cAAM,uBAAO,cAAc;AAC3B,cAAM,uBAAO,YAAY;AACzB,cAAM,uBAAO,SAAS;AAAA,EACxB;AAEA,MAAI,aAAa;AACf,cAAM,uBAAO,OAAO;AAAA,EACtB;AAEA,MAAI,iBAAiB;AACnB,cAAM,uBAAO,MAAM;AACnB,cAAM,+BAAe,kBAAkB;AAEvC,QAAI,UAAM,+BAAe,eAAe,MAAM,oCAAqB,SAAS;AAC1E,gBAAM,+BAAe,MAAM;AAAA,IAC7B;AAEA,QAAI,2BAA2B;AAC7B,gBAAM,+BAAe,kBAAkB;AAAA,IACzC;AAAA,EACF;AACF;AAQO,SAAS,mBAAmB,YAAmC;AACpE,QAAM,EAAE,OAAO,QAAI,4BAAU;AAAA;AAAA,IAE3B,MAAM;AAAA,IACN,SAAS;AAAA,MACP,YAAY,EAAE,MAAM,UAAU;AAAA,MAC9B,aAAa,EAAE,MAAM,UAAU;AAAA,IACjC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,aAAa,EAAE,OAAO,UAAU,KAAK;AAAA,IACrC,iBAAiB,EAAE,OAAO,WAAW,KAAK;AAAA,EAC5C;AACF;",
  "names": []
}
