@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/bundlers/esbuild-impl/fix-source-maps-plugin.d.mts

@@ -0,0 +1,34 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * This module defines an esbuild plugin that fixes source maps generated during development.
+ * It adjusts the paths in the source maps to be compatible with Obsidian's internal URL scheme.
+ * A plugin is only active during development builds.
+ */
+import type { Plugin } from 'esbuild';
+/**
+ * Parameters for {@link fixSourceMapsPlugin}.
+ */
+export interface FixSourceMapsPluginParams {
+    /**
+     * The paths to the output files containing the source maps.
+     */
+    readonly distPaths: string[];
+    /**
+     * A boolean indicating whether the build is a production build. The plugin only runs in non-production builds.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The name of the Obsidian plugin, used to construct the Obsidian-specific URLs.
+     */
+    readonly pluginName: string;
+}
+/**
+ * Creates an esbuild plugin that fixes source maps by adjusting the paths to be compatible
+ * with Obsidian's internal URL scheme.
+ *
+ * @param params - The parameters for the function.
+ * @returns An esbuild `Plugin` object that fixes source maps.
+ */
+export declare function fixSourceMapsPlugin(params: FixSourceMapsPluginParams): Plugin;

package/dist/lib/esm/bundlers/esbuild-impl/fix-source-maps-plugin.mjs

@@ -0,0 +1,116 @@
+/*
+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'
+  };
+
+  // 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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toPosixPath } from "@mnaoumov/typescript-lib/path";
+import { replaceAll } from "@mnaoumov/typescript-lib/string";
+import { existsSync } from "node:fs";
+import {
+  readFile,
+  writeFile
+} from "node:fs/promises";
+function fixSourceMapsPlugin(params) {
+  const {
+    distPaths,
+    isProductionBuild,
+    pluginName
+  } = params;
+  return {
+    name: "fix-source-maps",
+    setup(build) {
+      build.onEnd(async () => {
+        if (isProductionBuild) {
+          return;
+        }
+        for (const distPath of distPaths) {
+          if (!existsSync(distPath)) {
+            continue;
+          }
+          const content = await readFile(distPath, "utf-8");
+          const newContent = replaceAll({
+            $string: content,
+            replacer: ({ capturedGroupArguments: [prefix = "", sourceMapBase64 = "", suffix = ""] }) => `${prefix + fixSourceMap({
+              pluginName,
+              sourceMapBase64
+            }) + suffix.trim()}
+/* nosourcemap */`,
+            searchValue: /(?<Prefix>\n(?:\/\/|\/\*)# sourceMappingURL=data:application\/json;base64,)(?<SourceMapBase64>.+?)(?<Suffix>$|\n| \*\/)(?:.|\n)*/g
+          });
+          if (content !== newContent) {
+            await writeFile(distPath, newContent);
+          }
+        }
+      });
+    }
+  };
+}
+function convertPathToObsidianUrl(params) {
+  const { path, pluginName } = params;
+  const convertedPath = replaceAll({
+    $string: toPosixPath(path),
+    replacer: "",
+    searchValue: /^(?:\.\.\/)+/g
+  });
+  return `app://obsidian.md/plugin:${pluginName}/${convertedPath}`;
+}
+function fixSourceMap(params) {
+  const { pluginName, sourceMapBase64 } = params;
+  const sourceMapJson = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
+  const sourceMap = JSON.parse(sourceMapJson);
+  sourceMap.sources = (sourceMap.sources ?? []).map(
+    (path) => convertPathToObsidianUrl({
+      path,
+      pluginName
+    })
+  );
+  return Buffer.from(JSON.stringify(sourceMap)).toString("base64");
+}
+export {
+  fixSourceMapsPlugin
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/bundlers/esbuild-impl/fix-source-maps-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an esbuild plugin that fixes source maps generated during development.\n * It adjusts the paths in the source maps to be compatible with Obsidian's internal URL scheme.\n * A plugin is only active during development builds.\n */\n\n/* v8 ignore start -- esbuild plugin that rewrites source maps for Obsidian URL scheme; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\n\nimport { toPosixPath } from '@mnaoumov/typescript-lib/path';\nimport { replaceAll } from '@mnaoumov/typescript-lib/string';\nimport { existsSync } from 'node:fs';\nimport {\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\n/**\n * Parameters for {@link fixSourceMapsPlugin}.\n */\nexport interface FixSourceMapsPluginParams {\n  /**\n   * The paths to the output files containing the source maps.\n   */\n  readonly distPaths: string[];\n\n  /**\n   * A boolean indicating whether the build is a production build. The plugin only runs in non-production builds.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The name of the Obsidian plugin, used to construct the Obsidian-specific URLs.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * Parameters for {@link convertPathToObsidianUrl}.\n */\ninterface ConvertPathToObsidianUrlParams {\n  /**\n   * The original file path.\n   */\n  readonly path: string;\n\n  /**\n   * The name of the Obsidian plugin.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * Parameters for {@link fixSourceMap}.\n */\ninterface FixSourceMapParams {\n  /**\n   * The name of the Obsidian plugin, used to construct the Obsidian-specific URLs.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The base64-encoded source map content.\n   */\n  readonly sourceMapBase64: string;\n}\n\ninterface SourceMap {\n  sources: string[];\n}\n\n/**\n * Creates an esbuild plugin that fixes source maps by adjusting the paths to be compatible\n * with Obsidian's internal URL scheme.\n *\n * @param params - The parameters for the function.\n * @returns An esbuild `Plugin` object that fixes source maps.\n */\nexport function fixSourceMapsPlugin(params: FixSourceMapsPluginParams): Plugin {\n  const {\n    distPaths,\n    isProductionBuild,\n    pluginName\n  } = params;\n  return {\n    name: 'fix-source-maps',\n    setup(build): void {\n      build.onEnd(async () => {\n        if (isProductionBuild) {\n          return;\n        }\n\n        for (const distPath of distPaths) {\n          if (!existsSync(distPath)) {\n            continue;\n          }\n\n          const content = await readFile(distPath, 'utf-8');\n          const newContent = replaceAll({\n            $string: content,\n            replacer: ({ capturedGroupArguments: [prefix = '', sourceMapBase64 = '', suffix = ''] }) =>\n              `${\n                prefix + fixSourceMap({\n                  pluginName,\n                  sourceMapBase64\n                }) + suffix.trim()\n              }\\n/* nosourcemap */`,\n            searchValue: /(?<Prefix>\\n(?:\\/\\/|\\/\\*)# sourceMappingURL=data:application\\/json;base64,)(?<SourceMapBase64>.+?)(?<Suffix>$|\\n| \\*\\/)(?:.|\\n)*/g\n          });\n\n          if (content !== newContent) {\n            await writeFile(distPath, newContent);\n          }\n        }\n      });\n    }\n  };\n}\n\n/**\n * Converts a given file path to an Obsidian-specific URL.\n *\n * @param params - The parameters for the conversion.\n * @returns The converted path as an Obsidian-specific URL.\n */\nfunction convertPathToObsidianUrl(params: ConvertPathToObsidianUrlParams): string {\n  const { path, pluginName } = params;\n  const convertedPath = replaceAll({\n    $string: toPosixPath(path),\n    replacer: '',\n    searchValue: /^(?:\\.\\.\\/)+/g\n  });\n  return `app://obsidian.md/plugin:${pluginName}/${convertedPath}`;\n}\n\n/**\n * Adjusts the paths in the base64-encoded source map to be compatible with Obsidian's URL scheme.\n *\n * @param params - The parameters for adjusting the source map.\n * @returns A base64-encoded string with the adjusted source map.\n */\nfunction fixSourceMap(params: FixSourceMapParams): string {\n  const { pluginName, sourceMapBase64 } = params;\n  const sourceMapJson = Buffer.from(sourceMapBase64, 'base64').toString('utf-8');\n  const sourceMap = JSON.parse(sourceMapJson) as Partial<SourceMap>;\n  sourceMap.sources = (sourceMap.sources ?? []).map((path) =>\n    convertPathToObsidianUrl({\n      path,\n      pluginName\n    })\n  );\n  return Buffer.from(JSON.stringify(sourceMap)).toString('base64');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,mBAAmB;AAC5B,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA+DA,SAAS,oBAAoB,QAA2C;AAC7E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,OAAa;AACjB,YAAM,MAAM,YAAY;AACtB,YAAI,mBAAmB;AACrB;AAAA,QACF;AAEA,mBAAW,YAAY,WAAW;AAChC,cAAI,CAAC,WAAW,QAAQ,GAAG;AACzB;AAAA,UACF;AAEA,gBAAM,UAAU,MAAM,SAAS,UAAU,OAAO;AAChD,gBAAM,aAAa,WAAW;AAAA,YAC5B,SAAS;AAAA,YACT,UAAU,CAAC,EAAE,wBAAwB,CAAC,SAAS,IAAI,kBAAkB,IAAI,SAAS,EAAE,EAAE,MACpF,GACE,SAAS,aAAa;AAAA,cACpB;AAAA,cACA;AAAA,YACF,CAAC,IAAI,OAAO,KAAK,CACnB;AAAA;AAAA,YACF,aAAa;AAAA,UACf,CAAC;AAED,cAAI,YAAY,YAAY;AAC1B,kBAAM,UAAU,UAAU,UAAU;AAAA,UACtC;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAQA,SAAS,yBAAyB,QAAgD;AAChF,QAAM,EAAE,MAAM,WAAW,IAAI;AAC7B,QAAM,gBAAgB,WAAW;AAAA,IAC/B,SAAS,YAAY,IAAI;AAAA,IACzB,UAAU;AAAA,IACV,aAAa;AAAA,EACf,CAAC;AACD,SAAO,4BAA4B,UAAU,IAAI,aAAa;AAChE;AAQA,SAAS,aAAa,QAAoC;AACxD,QAAM,EAAE,YAAY,gBAAgB,IAAI;AACxC,QAAM,gBAAgB,OAAO,KAAK,iBAAiB,QAAQ,EAAE,SAAS,OAAO;AAC7E,QAAM,YAAY,KAAK,MAAM,aAAa;AAC1C,YAAU,WAAW,UAAU,WAAW,CAAC,GAAG;AAAA,IAAI,CAAC,SACjD,yBAAyB;AAAA,MACvB;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO,OAAO,KAAK,KAAK,UAAU,SAAS,CAAC,EAAE,SAAS,QAAQ;AACjE;",
  "names": []
}


package/dist/lib/esm/bundlers/esbuild-impl/index.d.mts

@@ -0,0 +1,7 @@
+/// <reference path="../../index.d.mts" />
+export * as 'copy-to-obsidian-plugins-folder-plugin' from './copy-to-obsidian-plugins-folder-plugin.mjs';
+export * as 'dependency' from './dependency.mjs';
+export * as 'fix-source-maps-plugin' from './fix-source-maps-plugin.mjs';
+export * as 'obsidian-plugin-builder' from './obsidian-plugin-builder.mjs';
+export * as 'preprocess-plugin' from './preprocess-plugin.mjs';
+export * as 'rename-css-plugin' from './rename-css-plugin.mjs';

package/dist/lib/esm/bundlers/esbuild-impl/index.mjs

@@ -0,0 +1,64 @@
+/*
+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'
+  };
+
+  // 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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import * as copy_to_obsidian_plugins_folder_plugin from "./copy-to-obsidian-plugins-folder-plugin.mjs";
+import * as dependency from "./dependency.mjs";
+import * as fix_source_maps_plugin from "./fix-source-maps-plugin.mjs";
+import * as obsidian_plugin_builder from "./obsidian-plugin-builder.mjs";
+import * as preprocess_plugin from "./preprocess-plugin.mjs";
+import * as rename_css_plugin from "./rename-css-plugin.mjs";
+export {
+  copy_to_obsidian_plugins_folder_plugin as "copy-to-obsidian-plugins-folder-plugin",
+  dependency,
+  fix_source_maps_plugin as "fix-source-maps-plugin",
+  obsidian_plugin_builder as "obsidian-plugin-builder",
+  preprocess_plugin as "preprocess-plugin",
+  rename_css_plugin as "rename-css-plugin"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2J1bmRsZXJzL2VzYnVpbGQtaW1wbC9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdjb3B5LXRvLW9ic2lkaWFuLXBsdWdpbnMtZm9sZGVyLXBsdWdpbicgZnJvbSAnLi9jb3B5LXRvLW9ic2lkaWFuLXBsdWdpbnMtZm9sZGVyLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnZGVwZW5kZW5jeScgZnJvbSAnLi9kZXBlbmRlbmN5LnRzJztcbmV4cG9ydCAqIGFzICdmaXgtc291cmNlLW1hcHMtcGx1Z2luJyBmcm9tICcuL2ZpeC1zb3VyY2UtbWFwcy1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ29ic2lkaWFuLXBsdWdpbi1idWlsZGVyJyBmcm9tICcuL29ic2lkaWFuLXBsdWdpbi1idWlsZGVyLnRzJztcbmV4cG9ydCAqIGFzICdwcmVwcm9jZXNzLXBsdWdpbicgZnJvbSAnLi9wcmVwcm9jZXNzLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAncmVuYW1lLWNzcy1wbHVnaW4nIGZyb20gJy4vcmVuYW1lLWNzcy1wbHVnaW4udHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLFlBQVlBLDRDQUE4QztBQUMxRCxZQUFZLGdCQUFrQjtBQUM5QixZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHVCQUF5QjtBQUNyQyxZQUFZQyx1QkFBeUI7IiwKICAibmFtZXMiOiBbImNvcHktdG8tb2JzaWRpYW4tcGx1Z2lucy1mb2xkZXItcGx1Z2luIiwgImZpeC1zb3VyY2UtbWFwcy1wbHVnaW4iLCAib2JzaWRpYW4tcGx1Z2luLWJ1aWxkZXIiLCAicHJlcHJvY2Vzcy1wbHVnaW4iLCAicmVuYW1lLWNzcy1wbHVnaW4iXQp9Cg==

package/dist/lib/esm/bundlers/esbuild-impl/obsidian-plugin-builder.d.mts

@@ -0,0 +1,98 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * This module provides functionality to build and bundle an Obsidian plugin using esbuild.
+ * It includes functions to handle the build process based on different build modes (development or production),
+ * and it sets up various esbuild plugins to preprocess, lint, fix source maps, and copy files to the Obsidian plugins folder.
+ */
+import type { BuildContext, BuildOptions as EsbuildOptions, Plugin } from 'esbuild';
+import { CliTaskResult } from '@mnaoumov/typescript-dev-toolkit/cli-utils';
+/**
+ * Enumeration representing the build modes.
+ */
+export declare enum BuildMode {
+    /**
+    Development mode for building the plugin
+     */
+    Development = 0,
+    /**
+    Production mode for building the plugin
+     */
+    Production = 1
+}
+/**
+ * Banner text to be included at the top of the generated files.
+ */
+export declare const banner = "/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n";
+/**
+ * Options for {@link buildObsidianPlugin}.
+ */
+export interface BuildObsidianPluginParams {
+    /**
+     * Custom esbuild plugins to be used during the build process.
+     */
+    readonly customEsbuildPlugins?: Plugin[];
+    /**
+     * Customizes the `esbuild` options.
+     */
+    readonly customizeEsbuildOptions?: (options: EsbuildOptions) => void;
+    /**
+     * A build mode, either `Development` or `Production`
+     */
+    readonly mode: BuildMode;
+    /**
+     * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.
+     */
+    readonly obsidianConfigFolder?: string;
+}
+/**
+ * Build parameters without the mode field, for use with {@link build} and {@link dev}.
+ */
+export interface BuildOptions {
+    /**
+     * Custom esbuild plugins to be used during the build process.
+     */
+    readonly customEsbuildPlugins?: Plugin[];
+    /**
+     * Customizes the `esbuild` options.
+     */
+    readonly customizeEsbuildOptions?: (options: EsbuildOptions) => void;
+    /**
+     * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.
+     */
+    readonly obsidianConfigFolder?: string;
+}
+/**
+ * Builds the Obsidian plugin in production mode using esbuild.
+ *
+ * @param options - Optional build parameters (mode is set to Production automatically).
+ * @returns A {@link Promise} that resolves when the build is complete.
+ */
+export declare function build(options?: BuildOptions): Promise<void>;
+/**
+ * Builds the Obsidian plugin based on the specified mode and configuration folder.
+ *
+ * @param params - The parameters for building the plugin.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.
+ */
+export declare function buildObsidianPlugin(params: BuildObsidianPluginParams): Promise<CliTaskResult>;
+/**
+ * Builds the Obsidian plugin in development mode using esbuild with watch.
+ *
+ * In addition to esbuild's own source-graph watch, the development build also watches the plugin's
+ * `node_modules` folder and restarts the whole build (including the type-check) when it changes, so a
+ * dependency reinstall or rebuild is picked up.
+ *
+ * @param options - Optional build parameters (mode is set to Development automatically).
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the build result.
+ */
+export declare function dev(options?: BuildOptions): Promise<CliTaskResult>;
+/**
+ * Invokes the build process with the provided build context.
+ *
+ * @param buildContext - The build context generated by esbuild.
+ * @param isProductionBuild - A boolean indicating whether the build is a production build.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.
+ */
+export declare function invokeEsbuild(buildContext: BuildContext, isProductionBuild: boolean): Promise<CliTaskResult>;

package/dist/lib/esm/bundlers/esbuild-impl/obsidian-plugin-builder.mjs

@@ -0,0 +1,255 @@
+/*
+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'
+  };
+
+  // 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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { customEsbuildOptionsPlugin } from "@mnaoumov/typescript-dev-toolkit/bundlers/esbuild-impl/custom-esbuild-options-plugin";
+import { fixEsmPlugin } from "@mnaoumov/typescript-dev-toolkit/bundlers/esbuild-impl/fix-esm-plugin";
+import { svelteWrapperPlugin } from "@mnaoumov/typescript-dev-toolkit/bundlers/esbuild-impl/svelte-wrapper-plugin";
+import { CliTaskResult } from "@mnaoumov/typescript-dev-toolkit/cli-utils";
+import { readPackageJson } from "@mnaoumov/typescript-dev-toolkit/npm";
+import { npmRun } from "@mnaoumov/typescript-dev-toolkit/npm-run";
+import { resolvePathFromRoot } from "@mnaoumov/typescript-dev-toolkit/root";
+import { invokeAsyncSafely } from "@mnaoumov/typescript-lib/async";
+import { extractDefaultExportInterop } from "@mnaoumov/typescript-lib/object-utils";
+import { join } from "@mnaoumov/typescript-lib/path";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { context } from "esbuild";
+import sassPlugin_ from "esbuild-sass-plugin";
+import {
+  existsSync,
+  watch
+} from "node:fs";
+import {
+  cp,
+  mkdir,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { builtinModules } from "node:module";
+import process, { loadEnvFile } from "node:process";
+import { ObsidianPluginRepoPaths } from "../../obsidian-plugin-repo-paths.mjs";
+import { copyToObsidianPluginsFolderPlugin } from "./copy-to-obsidian-plugins-folder-plugin.mjs";
+import { fixSourceMapsPlugin } from "./fix-source-maps-plugin.mjs";
+import { preprocessPlugin } from "./preprocess-plugin.mjs";
+import { renameCssPlugin } from "./rename-css-plugin.mjs";
+const sassPlugin = extractDefaultExportInterop(sassPlugin_);
+const NODE_MODULES_RESTART_DEBOUNCE_IN_MILLISECONDS = 1e3;
+var BuildMode = /* @__PURE__ */ ((BuildMode2) => {
+  BuildMode2[BuildMode2["Development"] = 0] = "Development";
+  BuildMode2[BuildMode2["Production"] = 1] = "Production";
+  return BuildMode2;
+})(BuildMode || {});
+const banner = `/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+`;
+async function build(options) {
+  const result = await buildObsidianPlugin({ ...options, mode: 1 /* Production */ });
+  result.throwOnFailure();
+}
+async function buildObsidianPlugin(params) {
+  await npmRun("build:compile");
+  const envPath = resolvePathFromRoot({ path: ".env" });
+  if (envPath && existsSync(envPath)) {
+    loadEnvFile(envPath);
+  }
+  const obsidianPluginBuilderEnv = process.env;
+  const obsidianConfigFolder = params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? "";
+  const isProductionBuild = params.mode === 1 /* Production */;
+  const distFolder = ensureNonNullable(
+    resolvePathFromRoot({ path: isProductionBuild ? ObsidianPluginRepoPaths.DistBuild : ObsidianPluginRepoPaths.DistDev }),
+    "Could not determine the dist folder"
+  );
+  if (existsSync(distFolder)) {
+    await rm(distFolder, { recursive: true });
+  }
+  await mkdir(distFolder, { recursive: true });
+  const distFileNames = [
+    ObsidianPluginRepoPaths.ManifestJson
+  ];
+  if (!isProductionBuild) {
+    await writeFile(join(distFolder, ObsidianPluginRepoPaths.HotReload), "", "utf-8");
+  }
+  for (const fileName of distFileNames) {
+    const localFile = ensureNonNullable(resolvePathFromRoot({ path: fileName }), `Could not determine the local file for ${fileName}`);
+    const distFile = join(distFolder, fileName);
+    if (existsSync(localFile)) {
+      await cp(localFile, distFile);
+    }
+  }
+  const distPath = join(distFolder, ObsidianPluginRepoPaths.MainJs);
+  const cssPath = join(distFolder, ObsidianPluginRepoPaths.StylesCss);
+  const packageJson = await readPackageJson();
+  const pluginName = packageJson.name ?? "(unknown)";
+  const buildOptions = {
+    banner: {
+      js: banner
+    },
+    bundle: true,
+    /*
+     * `conditions`, `mainFields` and `platform` are one decision, read together.
+     *
+     * The bundle is ONE `main.js` loaded both in Electron on desktop and in a bare WebView on a phone, so a
+     * dependency must resolve to its browser build. esbuild ADDS a condition of its own for `platform: 'node'`
+     * (`node`) and for `platform: 'browser'` (`browser`), and a `conditions` list cannot take one away. With
+     * `platform: 'node'` the effective set was `{ browser, node, import/require, default }`, so a package whose
+     * `exports` map lists `node` before `browser` shipped its Node build to phones — `fflate`'s `esm/index.mjs`
+     * opens with `createRequire` from `module`, which threw at load on mobile.
+     *
+     * `platform: 'neutral'` adds no platform condition, leaving exactly `browser` from the list below. It is
+     * chosen over `platform: 'browser'` because that one also changes what this bundle has always relied on:
+     * it defines `process.env.NODE_ENV` and applies a package's `browser` field remapping (which can stub a
+     * Node builtin to an empty object, breaking a dependency's desktop-only path). `mainFields` restates the
+     * `node` platform's default, because `neutral` has none of its own. Node builtins are marked external by name
+     * below — `node:*` included, since only `platform: 'node'` marks that prefix external by itself.
+     *
+     * Measured over 31 plugins built on this library, 2026-09-23, against `platform: 'node'`: the only modules
+     * that change are `vfile`, `unist-util-visit-parents` and `yaml` (each now takes its browser build instead
+     * of one importing `node:process` / `node:path` / `node:url`) and `esm-env`'s Node flag, which now reads
+     * false. Everything else in every bundle is identical up to identifier renaming.
+     */
+    conditions: ["browser"],
+    entryPoints: [
+      ensureNonNullable(
+        resolvePathFromRoot({ path: join(ObsidianPluginRepoPaths.Src, ObsidianPluginRepoPaths.MainTs) }),
+        "Could not determine the entry point for the plugin"
+      )
+    ],
+    external: [
+      "obsidian",
+      "electron",
+      "@codemirror/autocomplete",
+      "@codemirror/collab",
+      "@codemirror/commands",
+      "@codemirror/language",
+      "@codemirror/lint",
+      "@codemirror/search",
+      "@codemirror/state",
+      "@codemirror/view",
+      "@lezer/common",
+      "@lezer/highlight",
+      "@lezer/lr",
+      "esbuild",
+      "eslint",
+      ...builtinModules,
+      "node:*"
+    ],
+    format: "cjs",
+    keepNames: true,
+    logLevel: "info",
+    mainFields: ["main", "module"],
+    minify: isProductionBuild,
+    outfile: distPath,
+    platform: "neutral",
+    plugins: [
+      customEsbuildOptionsPlugin(params.customizeEsbuildOptions?.bind(params)),
+      svelteWrapperPlugin(isProductionBuild),
+      sassPlugin({
+        sourceMap: !isProductionBuild
+      }),
+      renameCssPlugin(distFolder),
+      preprocessPlugin(),
+      fixEsmPlugin(),
+      fixSourceMapsPlugin({ distPaths: [distPath, cssPath], isProductionBuild, pluginName }),
+      ...params.customEsbuildPlugins ?? [],
+      copyToObsidianPluginsFolderPlugin({ distFolder, isProductionBuild, obsidianConfigFolder, pluginName })
+    ],
+    sourcemap: !isProductionBuild && "inline",
+    target: "ES2022",
+    treeShaking: true
+  };
+  const buildContext = await context(buildOptions);
+  const result = await invokeEsbuild(buildContext, isProductionBuild);
+  if (!isProductionBuild) {
+    watchNodeModulesAndRestart(params, buildContext);
+  }
+  return result;
+}
+async function dev(options) {
+  return await buildObsidianPlugin({ ...options, mode: 0 /* Development */ });
+}
+async function invokeEsbuild(buildContext, isProductionBuild) {
+  if (isProductionBuild) {
+    const result = await buildContext.rebuild();
+    const isSuccess = result.errors.length === 0 && result.warnings.length === 0;
+    return CliTaskResult.Success(isSuccess);
+  }
+  await buildContext.watch();
+  return CliTaskResult.DoNotExit();
+}
+function watchNodeModulesAndRestart(params, buildContext) {
+  const nodeModulesPath = resolvePathFromRoot({ path: ObsidianPluginRepoPaths.NodeModules });
+  if (!nodeModulesPath || !existsSync(nodeModulesPath)) {
+    return;
+  }
+  let restartTimeout;
+  const watcher = watch(nodeModulesPath, { recursive: true }, () => {
+    if (restartTimeout) {
+      clearTimeout(restartTimeout);
+    }
+    restartTimeout = setTimeout(() => {
+      invokeAsyncSafely(restart);
+    }, NODE_MODULES_RESTART_DEBOUNCE_IN_MILLISECONDS);
+  });
+  async function restart() {
+    console.warn("Detected changes in node_modules. Restarting the build...");
+    watcher.close();
+    await buildContext.dispose();
+    await buildObsidianPlugin(params);
+  }
+}
+export {
+  BuildMode,
+  banner,
+  build,
+  buildObsidianPlugin,
+  dev,
+  invokeEsbuild
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/bundlers/esbuild-impl/obsidian-plugin-builder.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides functionality to build and bundle an Obsidian plugin using esbuild.\n * It includes functions to handle the build process based on different build modes (development or production),\n * and it sets up various esbuild plugins to preprocess, lint, fix source maps, and copy files to the Obsidian plugins folder.\n */\n\n/* v8 ignore start -- esbuild-based build pipeline with sass/svelte plugins and file watchers; requires a live esbuild context. */\n\nimport type {\n  BuildContext,\n  BuildOptions as EsbuildOptions,\n  Plugin\n} from 'esbuild';\n\nimport { customEsbuildOptionsPlugin } from '@mnaoumov/typescript-dev-toolkit/bundlers/esbuild-impl/custom-esbuild-options-plugin';\nimport { fixEsmPlugin } from '@mnaoumov/typescript-dev-toolkit/bundlers/esbuild-impl/fix-esm-plugin';\nimport { svelteWrapperPlugin } from '@mnaoumov/typescript-dev-toolkit/bundlers/esbuild-impl/svelte-wrapper-plugin';\nimport { CliTaskResult } from '@mnaoumov/typescript-dev-toolkit/cli-utils';\nimport { readPackageJson } from '@mnaoumov/typescript-dev-toolkit/npm';\nimport { npmRun } from '@mnaoumov/typescript-dev-toolkit/npm-run';\nimport { resolvePathFromRoot } from '@mnaoumov/typescript-dev-toolkit/root';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport { extractDefaultExportInterop } from '@mnaoumov/typescript-lib/object-utils';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { context } from 'esbuild';\n// eslint-disable-next-line import-x/no-rename-default -- We need a temp variable to apply `extractDefaultExportInterop()` fix below.\nimport sassPlugin_ from 'esbuild-sass-plugin';\nimport {\n  existsSync,\n  watch\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { builtinModules } from 'node:module';\nimport process, { loadEnvFile } from 'node:process';\n\nimport { ObsidianPluginRepoPaths } from '../../obsidian-plugin-repo-paths.ts';\nimport { copyToObsidianPluginsFolderPlugin } from './copy-to-obsidian-plugins-folder-plugin.ts';\nimport { fixSourceMapsPlugin } from './fix-source-maps-plugin.ts';\nimport { preprocessPlugin } from './preprocess-plugin.ts';\nimport { renameCssPlugin } from './rename-css-plugin.ts';\n\nconst sassPlugin = extractDefaultExportInterop(sassPlugin_);\n\n/**\n * Debounce window for restarting a development build after `node_modules` changes. A reinstall or a\n * dependency rebuild touches many files in quick succession, so we wait for the churn to settle\n * before restarting once.\n */\nconst NODE_MODULES_RESTART_DEBOUNCE_IN_MILLISECONDS = 1000;\n\n/**\n * Enumeration representing the build modes.\n */\nexport enum BuildMode {\n  /**\n  Development mode for building the plugin\n   */\n  Development,\n  /**\n  Production mode for building the plugin\n   */\n  Production\n}\n\n/**\n * Banner text to be included at the top of the generated files.\n */\nexport const banner = `/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n`;\n\n/**\n * Options for {@link buildObsidianPlugin}.\n */\nexport interface BuildObsidianPluginParams {\n  /**\n   * Custom esbuild plugins to be used during the build process.\n   */\n  readonly customEsbuildPlugins?: Plugin[];\n\n  /**\n   * Customizes the `esbuild` options.\n   */\n  readonly customizeEsbuildOptions?: (options: EsbuildOptions) => void;\n\n  /**\n   * A build mode, either `Development` or `Production`\n   */\n  readonly mode: BuildMode;\n\n  /**\n   * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.\n   */\n  readonly obsidianConfigFolder?: string;\n}\n\n/**\n * Build parameters without the mode field, for use with {@link build} and {@link dev}.\n */\nexport interface BuildOptions {\n  /**\n   * Custom esbuild plugins to be used during the build process.\n   */\n  readonly customEsbuildPlugins?: Plugin[];\n\n  /**\n   * Customizes the `esbuild` options.\n   */\n  readonly customizeEsbuildOptions?: (options: EsbuildOptions) => void;\n\n  /**\n   * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.\n   */\n  readonly obsidianConfigFolder?: string;\n}\n\ninterface ObsidianPluginBuilderEnv {\n  OBSIDIAN_CONFIG_FOLDER: string;\n}\n\n/**\n * Builds the Obsidian plugin in production mode using esbuild.\n *\n * @param options - Optional build parameters (mode is set to Production automatically).\n * @returns A {@link Promise} that resolves when the build is complete.\n */\nexport async function build(options?: BuildOptions): Promise<void> {\n  const result = await buildObsidianPlugin({ ...options, mode: BuildMode.Production });\n  result.throwOnFailure();\n}\n\n/**\n * Builds the Obsidian plugin based on the specified mode and configuration folder.\n *\n * @param params - The parameters for building the plugin.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function buildObsidianPlugin(params: BuildObsidianPluginParams): Promise<CliTaskResult> {\n  await npmRun('build:compile');\n  const envPath = resolvePathFromRoot({ path: '.env' });\n  if (envPath && existsSync(envPath)) {\n    loadEnvFile(envPath);\n  }\n  const obsidianPluginBuilderEnv = process.env as Partial<ObsidianPluginBuilderEnv>;\n\n  const obsidianConfigFolder = params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? '';\n  const isProductionBuild = params.mode === BuildMode.Production;\n\n  const distFolder = ensureNonNullable(\n    resolvePathFromRoot({ path: isProductionBuild ? ObsidianPluginRepoPaths.DistBuild : ObsidianPluginRepoPaths.DistDev }),\n    'Could not determine the dist folder'\n  );\n\n  if (existsSync(distFolder)) {\n    await rm(distFolder, { recursive: true });\n  }\n  await mkdir(distFolder, { recursive: true });\n\n  const distFileNames = [\n    ObsidianPluginRepoPaths.ManifestJson\n  ];\n  if (!isProductionBuild) {\n    await writeFile(join(distFolder, ObsidianPluginRepoPaths.HotReload), '', 'utf-8');\n  }\n\n  for (const fileName of distFileNames) {\n    const localFile = ensureNonNullable(resolvePathFromRoot({ path: fileName }), `Could not determine the local file for ${fileName}`);\n    const distFile = join(distFolder, fileName);\n\n    if (existsSync(localFile)) {\n      await cp(localFile, distFile);\n    }\n  }\n\n  const distPath = join(distFolder, ObsidianPluginRepoPaths.MainJs);\n  const cssPath = join(distFolder, ObsidianPluginRepoPaths.StylesCss);\n\n  const packageJson = await readPackageJson();\n  const pluginName = packageJson.name ?? '(unknown)';\n\n  const buildOptions: EsbuildOptions = {\n    banner: {\n      js: banner\n    },\n    bundle: true,\n    /*\n     * `conditions`, `mainFields` and `platform` are one decision, read together.\n     *\n     * The bundle is ONE `main.js` loaded both in Electron on desktop and in a bare WebView on a phone, so a\n     * dependency must resolve to its browser build. esbuild ADDS a condition of its own for `platform: 'node'`\n     * (`node`) and for `platform: 'browser'` (`browser`), and a `conditions` list cannot take one away. With\n     * `platform: 'node'` the effective set was `{ browser, node, import/require, default }`, so a package whose\n     * `exports` map lists `node` before `browser` shipped its Node build to phones \u2014 `fflate`'s `esm/index.mjs`\n     * opens with `createRequire` from `module`, which threw at load on mobile.\n     *\n     * `platform: 'neutral'` adds no platform condition, leaving exactly `browser` from the list below. It is\n     * chosen over `platform: 'browser'` because that one also changes what this bundle has always relied on:\n     * it defines `process.env.NODE_ENV` and applies a package's `browser` field remapping (which can stub a\n     * Node builtin to an empty object, breaking a dependency's desktop-only path). `mainFields` restates the\n     * `node` platform's default, because `neutral` has none of its own. Node builtins are marked external by name\n     * below \u2014 `node:*` included, since only `platform: 'node'` marks that prefix external by itself.\n     *\n     * Measured over 31 plugins built on this library, 2026-09-23, against `platform: 'node'`: the only modules\n     * that change are `vfile`, `unist-util-visit-parents` and `yaml` (each now takes its browser build instead\n     * of one importing `node:process` / `node:path` / `node:url`) and `esm-env`'s Node flag, which now reads\n     * false. Everything else in every bundle is identical up to identifier renaming.\n     */\n    conditions: ['browser'],\n    entryPoints: [\n      ensureNonNullable(\n        resolvePathFromRoot({ path: join(ObsidianPluginRepoPaths.Src, ObsidianPluginRepoPaths.MainTs) }),\n        'Could not determine the entry point for the plugin'\n      )\n    ],\n    external: [\n      'obsidian',\n      'electron',\n      '@codemirror/autocomplete',\n      '@codemirror/collab',\n      '@codemirror/commands',\n      '@codemirror/language',\n      '@codemirror/lint',\n      '@codemirror/search',\n      '@codemirror/state',\n      '@codemirror/view',\n      '@lezer/common',\n      '@lezer/highlight',\n      '@lezer/lr',\n      'esbuild',\n      'eslint',\n      ...builtinModules,\n      'node:*'\n    ],\n    format: 'cjs',\n    keepNames: true,\n    logLevel: 'info',\n    mainFields: ['main', 'module'],\n    minify: isProductionBuild,\n    outfile: distPath,\n    platform: 'neutral',\n    plugins: [\n      customEsbuildOptionsPlugin(params.customizeEsbuildOptions?.bind(params)),\n      svelteWrapperPlugin(isProductionBuild),\n      sassPlugin({\n        sourceMap: !isProductionBuild\n      }),\n      renameCssPlugin(distFolder),\n      preprocessPlugin(),\n      fixEsmPlugin(),\n      fixSourceMapsPlugin({ distPaths: [distPath, cssPath], isProductionBuild, pluginName }),\n      ...params.customEsbuildPlugins ?? [],\n      copyToObsidianPluginsFolderPlugin({ distFolder, isProductionBuild, obsidianConfigFolder, pluginName })\n    ],\n    sourcemap: !isProductionBuild && 'inline',\n    target: 'ES2022',\n    treeShaking: true\n  };\n\n  const buildContext = await context(buildOptions);\n  const result = await invokeEsbuild(buildContext, isProductionBuild);\n  if (!isProductionBuild) {\n    watchNodeModulesAndRestart(params, buildContext);\n  }\n  return result;\n}\n\n/**\n * Builds the Obsidian plugin in development mode using esbuild with watch.\n *\n * In addition to esbuild's own source-graph watch, the development build also watches the plugin's\n * `node_modules` folder and restarts the whole build (including the type-check) when it changes, so a\n * dependency reinstall or rebuild is picked up.\n *\n * @param options - Optional build parameters (mode is set to Development automatically).\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the build result.\n */\n// eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Intentionally shares BuildOptions with build().\nexport async function dev(options?: BuildOptions): Promise<CliTaskResult> {\n  return await buildObsidianPlugin({ ...options, mode: BuildMode.Development });\n}\n\n/**\n * Invokes the build process with the provided build context.\n *\n * @param buildContext - The build context generated by esbuild.\n * @param isProductionBuild - A boolean indicating whether the build is a production build.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function invokeEsbuild(buildContext: BuildContext, isProductionBuild: boolean): Promise<CliTaskResult> {\n  if (isProductionBuild) {\n    const result = await buildContext.rebuild();\n    const isSuccess = result.errors.length === 0 && result.warnings.length === 0;\n    return CliTaskResult.Success(isSuccess);\n  }\n  await buildContext.watch();\n  return CliTaskResult.DoNotExit();\n}\n\n/**\n * Watches the plugin's `node_modules` folder and restarts the development build when it changes.\n *\n * The esbuild watcher only tracks files in its build graph and only ever re-bundles \u2014 it never\n * re-runs the `build:compile` type-check, and it ignores `node_modules` changes outside the graph\n * (a reinstall, or a dependency file not currently imported). On any (debounced) change anywhere in\n * the `node_modules` tree, the current build context is disposed and the whole development build is\n * restarted, re-running the full pipeline.\n *\n * @param params - The parameters the build was started with, used to restart it.\n * @param buildContext - The esbuild context to dispose before restarting.\n */\nfunction watchNodeModulesAndRestart(params: BuildObsidianPluginParams, buildContext: BuildContext): void {\n  const nodeModulesPath = resolvePathFromRoot({ path: ObsidianPluginRepoPaths.NodeModules });\n  if (!nodeModulesPath || !existsSync(nodeModulesPath)) {\n    return;\n  }\n\n  let restartTimeout: ReturnType<typeof setTimeout> | undefined;\n  const watcher = watch(nodeModulesPath, { recursive: true }, () => {\n    if (restartTimeout) {\n      // eslint-disable-next-line obsidianmd/prefer-window-timers -- Node build-tool context; `window` is not available.\n      clearTimeout(restartTimeout);\n    }\n    // eslint-disable-next-line obsidianmd/prefer-window-timers -- Node build-tool context; `window` is not available.\n    restartTimeout = setTimeout(() => {\n      invokeAsyncSafely(restart);\n    }, NODE_MODULES_RESTART_DEBOUNCE_IN_MILLISECONDS);\n  });\n\n  async function restart(): Promise<void> {\n    console.warn('Detected changes in node_modules. Restarting the build...');\n    watcher.close();\n    await buildContext.dispose();\n    await buildObsidianPlugin(params);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["BuildMode"]
}
