@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/cjs/bundlers/rollup.cjs

@@ -0,0 +1,218 @@
+/*
+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 = 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 rollup_exports = {};
+__export(rollup_exports, {
+  applyRollupInputDefaults: () => applyRollupInputDefaults,
+  applyRollupOutputDefaults: () => applyRollupOutputDefaults,
+  obsidianPluginRollup: () => obsidianPluginRollup
+});
+module.exports = __toCommonJS(rollup_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_obsidian_plugin_build = require('./obsidian-plugin-build.cjs');
+var import_obsidian_plugin_features = require('./obsidian-plugin-features.cjs');
+var import_obsidian_plugins_folder_deployment = require('./obsidian-plugins-folder-deployment.cjs');
+var import_rollup_compatible_features = require('./rollup-compatible-features.cjs');
+var import_rollup_compatible = require('./rollup-compatible.cjs');
+function applyRollupInputDefaults(params) {
+  const { buildContext, inputOptions } = params;
+  const jsxImportSource = (0, import_obsidian_plugin_features.getJsxImportSource)(params.features?.framework);
+  return {
+    ...inputOptions,
+    external: (0, import_rollup_compatible.combineExternal)(inputOptions.external),
+    input: inputOptions.input ?? buildContext.entryPoint,
+    ...jsxImportSource !== void 0 && inputOptions.jsx === void 0 && { jsx: { jsxImportSource, mode: "automatic" } }
+  };
+}
+function applyRollupOutputDefaults(params) {
+  const { buildContext, outputOptions } = params;
+  const hasOutputLocation = outputOptions.file !== void 0 || outputOptions.dir !== void 0;
+  return {
+    ...outputOptions,
+    banner: outputOptions.banner ?? (0, import_obsidian_plugin_build.getObsidianPluginBanner)("rollup"),
+    format: outputOptions.format ?? "cjs",
+    ...!hasOutputLocation && { file: buildContext.mainJsPath },
+    // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.
+    inlineDynamicImports: outputOptions.inlineDynamicImports ?? true,
+    sourcemap: outputOptions.sourcemap ?? (!buildContext.isProductionBuild && "inline")
+  };
+}
+function obsidianPluginRollup(options = {}) {
+  const state = {
+    buildContext: void 0,
+    isDistFolderCleaned: false
+  };
+  function getBuildContext() {
+    if (!state.buildContext) {
+      throw new Error("The obsidian-plugin rollup plugin has not resolved its build context: its `options` hook did not run.");
+    }
+    return state.buildContext;
+  }
+  const featurePlugin = (0, import_rollup_compatible_features.createRollupCompatibleFeaturePlugin)({
+    features: options,
+    isProductionBuild: () => getBuildContext().isProductionBuild,
+    shouldCompileStylesheets: true,
+    shouldReplaceDefines: true
+  });
+  const plugin = {
+    generateBundle: {
+      handler(_outputOptions, bundle) {
+        (0, import_rollup_compatible.renameCssAssets)(this, bundle);
+      },
+      order: "post"
+    },
+    name: "obsidian-plugin",
+    async options(inputOptions) {
+      const mode = options.mode ?? (this.meta.watchMode ? import_obsidian_plugin_build.BuildMode.Development : import_obsidian_plugin_build.BuildMode.Production);
+      state.buildContext = await (0, import_obsidian_plugin_build.resolveObsidianPluginBuildContext)({ ...options, mode });
+      return applyRollupInputDefaults({ buildContext: state.buildContext, features: options, inputOptions });
+    },
+    outputOptions(outputOptions) {
+      return applyRollupOutputDefaults({ buildContext: getBuildContext(), outputOptions });
+    },
+    async renderStart(outputOptions) {
+      if (state.isDistFolderCleaned) {
+        return;
+      }
+      state.isDistFolderCleaned = true;
+      await (0, import_obsidian_plugin_build.cleanObsidianPluginDistFolder)(getOutputFolder(outputOptions));
+    },
+    async writeBundle(outputOptions) {
+      const buildContext = { ...getBuildContext(), distFolder: getOutputFolder(outputOptions) };
+      await (0, import_obsidian_plugin_build.completeObsidianPluginDistFolder)(buildContext);
+      await (0, import_obsidian_plugins_folder_deployment.deployToObsidianPluginsFolder)(buildContext);
+    }
+  };
+  return [plugin, featurePlugin, (0, import_rollup_compatible_features.createUnpluginVuePlugin)({ bundler: "rollup", features: options })];
+}
+function getOutputFolder(outputOptions) {
+  return outputOptions.dir ?? (0, import_path.dirname)(outputOptions.file ?? "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyRollupInputDefaults,
+  applyRollupOutputDefaults,
+  obsidianPluginRollup
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/rollup.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with rollup: a rollup plugin that gives a build the same `main.js` +\n * `styles.css` + `manifest.json` layout the esbuild builder produces, deploys a watch build into the vault,\n * and fills in only the options the consumer's own `rollup.config` leaves unset.\n *\n * `rollup` is an optional peer dependency and this module only imports its types, so a plugin built with\n * esbuild installs nothing extra.\n */\n\nimport type {\n  InputOptions,\n  InputPluginOption,\n  NormalizedOutputOptions,\n  OutputOptions,\n  Plugin\n} from 'rollup';\n\nimport { dirname } from '@mnaoumov/typescript-lib/path';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\n\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport { getJsxImportSource } from './obsidian-plugin-features.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\nimport {\n  createRollupCompatibleFeaturePlugin,\n  createUnpluginVuePlugin\n} from './rollup-compatible-features.ts';\nimport {\n  combineExternal,\n  renameCssAssets\n} from './rollup-compatible.ts';\n\n/**\n * Parameters for {@link applyRollupInputDefaults}.\n */\nexport interface ApplyRollupInputDefaultsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * The build features.\n   */\n  readonly features?: ObsidianPluginFeatureOptions;\n\n  /**\n   * The consumer's input options.\n   */\n  readonly inputOptions: InputOptions;\n}\n\n/**\n * Parameters for {@link applyRollupOutputDefaults}.\n */\nexport interface ApplyRollupOutputDefaultsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * The consumer's output options.\n   */\n  readonly outputOptions: OutputOptions;\n}\n\n/**\n * Options for {@link obsidianPluginRollup}.\n */\nexport interface ObsidianPluginRollupOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * The build mode. Defaults to {@link BuildMode.Development} in watch mode (`rollup --watch`) and\n   * {@link BuildMode.Production} otherwise.\n   */\n  readonly mode?: BuildMode;\n}\n\n/**\n * The state one {@link obsidianPluginRollup} instance keeps across the hooks of a build, and across the\n * rebuilds of a watch.\n */\ninterface ObsidianPluginRollupState {\n  buildContext: ObsidianPluginBuildContext | undefined;\n  isDistFolderCleaned: boolean;\n}\n\n/**\n * Fills in the rollup input options the consumer left unset.\n *\n * @param params - The {@link ApplyRollupInputDefaultsParams}.\n * @returns The input options with the plugin's defaults applied.\n */\nexport function applyRollupInputDefaults(params: ApplyRollupInputDefaultsParams): InputOptions {\n  const { buildContext, inputOptions } = params;\n  const jsxImportSource = getJsxImportSource(params.features?.framework);\n  return {\n    ...inputOptions,\n    external: combineExternal(inputOptions.external),\n    input: inputOptions.input ?? buildContext.entryPoint,\n    ...(jsxImportSource !== undefined && inputOptions.jsx === undefined && { jsx: { jsxImportSource, mode: 'automatic' } })\n  };\n}\n\n/**\n * Fills in the rollup output options the consumer left unset.\n *\n * @param params - The {@link ApplyRollupOutputDefaultsParams}.\n * @returns The output options with the plugin's defaults applied.\n */\nexport function applyRollupOutputDefaults(params: ApplyRollupOutputDefaultsParams): OutputOptions {\n  const { buildContext, outputOptions } = params;\n  const hasOutputLocation = outputOptions.file !== undefined || outputOptions.dir !== undefined;\n  return {\n    ...outputOptions,\n    banner: outputOptions.banner ?? getObsidianPluginBanner('rollup'),\n    format: outputOptions.format ?? 'cjs',\n    ...(!hasOutputLocation && { file: buildContext.mainJsPath }),\n    // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.\n    inlineDynamicImports: outputOptions.inlineDynamicImports ?? true,\n    sourcemap: outputOptions.sourcemap ?? (!buildContext.isProductionBuild && 'inline')\n  };\n}\n\n/**\n * Creates a rollup plugin that builds an Obsidian plugin.\n *\n * What it does, each only when the consumer's config has not said otherwise:\n *\n * - `input` is `src/main.ts`.\n * - The output is one CommonJS `main.js` in `dist/build` (`dist/dev` in watch mode), with dynamic imports\n *   inlined, the generated-file banner, and an inline source map in development.\n *\n * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are\n * external beside the consumer's own `external`, the output folder is emptied before the first write,\n * every emitted CSS file ends up in `styles.css`, `manifest.json` (and in development `.hotreload`) is\n * copied beside it, and a development build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.\n *\n * TypeScript, dependency resolution and minification stay the consumer's choice of rollup plugins, as they would be\n * without this one. The build features ({@link ObsidianPluginFeatureOptions}) are the plugin's:\n *\n * - `framework: 'react' | 'preact'` sets rollup's `jsx` option to the automatic runtime (unless set), and the\n *   TypeScript plugin reads the same from the toolkit's tsconfig preset.\n * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds\n *   `unplugin-vue`.\n * - Any framework replaces `process.env.NODE_ENV` (and Vue's feature flags) in the bundled code.\n * - `styles` compiles every stylesheet itself (PostCSS, Tailwind, CSS modules), so rollup needs no CSS plugin; leave\n *   it out. `styles: {}` compiles plain CSS.\n * - `wasm` imports a `.wasm` module as its bytes.\n *\n * @param options - The {@link ObsidianPluginRollupOptions}.\n * @returns The rollup plugins, which rollup takes as one entry of its `plugins`.\n */\nexport function obsidianPluginRollup(options: ObsidianPluginRollupOptions = {}): InputPluginOption[] {\n  const state: ObsidianPluginRollupState = {\n    buildContext: undefined,\n    isDistFolderCleaned: false\n  };\n\n  /* v8 ignore start -- Rollup hooks; exercised by the bundler integration test against a real rollup build. */\n  function getBuildContext(): ObsidianPluginBuildContext {\n    if (!state.buildContext) {\n      throw new Error('The obsidian-plugin rollup plugin has not resolved its build context: its `options` hook did not run.');\n    }\n    return state.buildContext;\n  }\n\n  const featurePlugin = createRollupCompatibleFeaturePlugin({\n    features: options,\n    isProductionBuild: () => getBuildContext().isProductionBuild,\n    shouldCompileStylesheets: true,\n    shouldReplaceDefines: true\n  });\n\n  const plugin: Plugin = {\n    generateBundle: {\n      handler(_outputOptions, bundle): void {\n        renameCssAssets(this, bundle);\n      },\n      order: 'post'\n    },\n    name: 'obsidian-plugin',\n    async options(inputOptions): Promise<InputOptions> {\n      const mode = options.mode ?? (this.meta.watchMode ? BuildMode.Development : BuildMode.Production);\n      state.buildContext = await resolveObsidianPluginBuildContext({ ...options, mode });\n      return applyRollupInputDefaults({ buildContext: state.buildContext, features: options, inputOptions });\n    },\n    outputOptions(outputOptions): OutputOptions {\n      return applyRollupOutputDefaults({ buildContext: getBuildContext(), outputOptions });\n    },\n    async renderStart(outputOptions): Promise<void> {\n      if (state.isDistFolderCleaned) {\n        return;\n      }\n      state.isDistFolderCleaned = true;\n      await cleanObsidianPluginDistFolder(getOutputFolder(outputOptions));\n    },\n    async writeBundle(outputOptions): Promise<void> {\n      const buildContext = { ...getBuildContext(), distFolder: getOutputFolder(outputOptions) };\n      await completeObsidianPluginDistFolder(buildContext);\n      await deployToObsidianPluginsFolder(buildContext);\n    }\n  };\n  return [plugin, featurePlugin as Plugin, createUnpluginVuePlugin({ bundler: 'rollup', features: options }) as Promise<null | Plugin>];\n  /* v8 ignore stop */\n}\n\n/* v8 ignore start -- Part of the rollup hooks above. */\nfunction getOutputFolder(outputOptions: NormalizedOutputOptions): string {\n  return outputOptions.dir ?? dirname(outputOptions.file ?? '');\n}\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/bundlers/rollup.d.cts

@@ -0,0 +1,99 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Builds an Obsidian plugin with rollup: a rollup plugin that gives a build the same `main.js` +
+ * `styles.css` + `manifest.json` layout the esbuild builder produces, deploys a watch build into the vault,
+ * and fills in only the options the consumer's own `rollup.config` leaves unset.
+ *
+ * `rollup` is an optional peer dependency and this module only imports its types, so a plugin built with
+ * esbuild installs nothing extra.
+ */
+import type { InputOptions, InputPluginOption, OutputOptions } from 'rollup' with { 'resolution-mode': 'import' };
+import type { ObsidianPluginBuildContext, ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.cjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.cjs';
+import { BuildMode } from './obsidian-plugin-build.cjs';
+/**
+ * Parameters for {@link applyRollupInputDefaults}.
+ */
+export interface ApplyRollupInputDefaultsParams {
+    /**
+     * The build context.
+     */
+    readonly buildContext: ObsidianPluginBuildContext;
+    /**
+     * The build features.
+     */
+    readonly features?: ObsidianPluginFeatureOptions;
+    /**
+     * The consumer's input options.
+     */
+    readonly inputOptions: InputOptions;
+}
+/**
+ * Parameters for {@link applyRollupOutputDefaults}.
+ */
+export interface ApplyRollupOutputDefaultsParams {
+    /**
+     * The build context.
+     */
+    readonly buildContext: ObsidianPluginBuildContext;
+    /**
+     * The consumer's output options.
+     */
+    readonly outputOptions: OutputOptions;
+}
+/**
+ * Options for {@link obsidianPluginRollup}.
+ */
+export interface ObsidianPluginRollupOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {
+    /**
+     * The build mode. Defaults to {@link BuildMode.Development} in watch mode (`rollup --watch`) and
+     * {@link BuildMode.Production} otherwise.
+     */
+    readonly mode?: BuildMode;
+}
+/**
+ * Fills in the rollup input options the consumer left unset.
+ *
+ * @param params - The {@link ApplyRollupInputDefaultsParams}.
+ * @returns The input options with the plugin's defaults applied.
+ */
+export declare function applyRollupInputDefaults(params: ApplyRollupInputDefaultsParams): InputOptions;
+/**
+ * Fills in the rollup output options the consumer left unset.
+ *
+ * @param params - The {@link ApplyRollupOutputDefaultsParams}.
+ * @returns The output options with the plugin's defaults applied.
+ */
+export declare function applyRollupOutputDefaults(params: ApplyRollupOutputDefaultsParams): OutputOptions;
+/**
+ * Creates a rollup plugin that builds an Obsidian plugin.
+ *
+ * What it does, each only when the consumer's config has not said otherwise:
+ *
+ * - `input` is `src/main.ts`.
+ * - The output is one CommonJS `main.js` in `dist/build` (`dist/dev` in watch mode), with dynamic imports
+ *   inlined, the generated-file banner, and an inline source map in development.
+ *
+ * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are
+ * external beside the consumer's own `external`, the output folder is emptied before the first write,
+ * every emitted CSS file ends up in `styles.css`, `manifest.json` (and in development `.hotreload`) is
+ * copied beside it, and a development build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.
+ *
+ * TypeScript, dependency resolution and minification stay the consumer's choice of rollup plugins, as they would be
+ * without this one. The build features ({@link ObsidianPluginFeatureOptions}) are the plugin's:
+ *
+ * - `framework: 'react' | 'preact'` sets rollup's `jsx` option to the automatic runtime (unless set), and the
+ *   TypeScript plugin reads the same from the toolkit's tsconfig preset.
+ * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds
+ *   `unplugin-vue`.
+ * - Any framework replaces `process.env.NODE_ENV` (and Vue's feature flags) in the bundled code.
+ * - `styles` compiles every stylesheet itself (PostCSS, Tailwind, CSS modules), so rollup needs no CSS plugin; leave
+ *   it out. `styles: {}` compiles plain CSS.
+ * - `wasm` imports a `.wasm` module as its bytes.
+ *
+ * @param options - The {@link ObsidianPluginRollupOptions}.
+ * @returns The rollup plugins, which rollup takes as one entry of its `plugins`.
+ */
+export declare function obsidianPluginRollup(options?: ObsidianPluginRollupOptions): InputPluginOption[];

package/dist/lib/cjs/bundlers/vite.cjs

@@ -0,0 +1,229 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(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 = 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 vite_exports = {};
+__export(vite_exports, {
+  getViteBuildMode: () => getViteBuildMode,
+  getViteConfigDefaults: () => getViteConfigDefaults,
+  getViteFeatureConfig: () => getViteFeatureConfig,
+  obsidianPluginVite: () => obsidianPluginVite
+});
+module.exports = __toCommonJS(vite_exports);
+var import_obsidian_plugin_build = require('./obsidian-plugin-build.cjs');
+var import_obsidian_plugin_features = require('./obsidian-plugin-features.cjs');
+var import_obsidian_plugin_transforms = require('./obsidian-plugin-transforms.cjs');
+var import_obsidian_plugins_folder_deployment = require('./obsidian-plugins-folder-deployment.cjs');
+var import_rollup_compatible_features = require('./rollup-compatible-features.cjs');
+var import_rollup_compatible = require('./rollup-compatible.cjs');
+function getViteBuildMode(userConfig, env) {
+  return userConfig.build?.watch || env.mode === "development" ? import_obsidian_plugin_build.BuildMode.Development : import_obsidian_plugin_build.BuildMode.Production;
+}
+function getViteConfigDefaults(userConfig, buildContext) {
+  const build = userConfig.build ?? {};
+  const rolldownOptions = build.rolldownOptions ?? build.rollupOptions ?? {};
+  const output = Array.isArray(rolldownOptions.output) ? void 0 : rolldownOptions.output ?? {};
+  return {
+    build: {
+      // An Obsidian release ships `main.js` and `styles.css` and nothing else, so any asset emitted beside
+      // the bundle is a file the installed plugin looks for and does not find.
+      assetsInlineLimit: build.assetsInlineLimit ?? Number.MAX_SAFE_INTEGER,
+      // eslint-disable-next-line unicorn/name-replacements -- `emptyOutDir` is the name vite's config reads.
+      emptyOutDir: false,
+      lib: build.lib ?? {
+        cssFileName: "styles",
+        entry: buildContext.entryPoint,
+        fileName: () => "main.js",
+        formats: ["cjs"]
+      },
+      minify: build.minify ?? buildContext.isProductionBuild,
+      // eslint-disable-next-line unicorn/name-replacements -- `outDir` is the name vite's config reads.
+      outDir: buildContext.distFolder,
+      rolldownOptions: {
+        external: (0, import_rollup_compatible.combineExternal)(rolldownOptions.external),
+        ...output !== void 0 && {
+          output: {
+            // `postBanner` rather than `banner`: it is added after minification, which strips an ordinary comment.
+            ...output.banner === void 0 && output.postBanner === void 0 && { postBanner: (0, import_obsidian_plugin_build.getObsidianPluginBanner)("vite") },
+            // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.
+            // eslint-disable-next-line @typescript-eslint/no-deprecated -- A consumer's config may still set the deprecated option, which then wins.
+            ...output.codeSplitting === void 0 && output.inlineDynamicImports === void 0 && { codeSplitting: false }
+          }
+        }
+      },
+      sourcemap: build.sourcemap ?? (!buildContext.isProductionBuild && "inline")
+    }
+  };
+}
+function getViteFeatureConfig(params) {
+  const { features, isProductionBuild, postcssConfig, userConfig } = params;
+  const config = {};
+  const userDefine = userConfig.define ?? {};
+  const define = Object.fromEntries(
+    Object.entries((0, import_obsidian_plugin_features.getFrameworkDefines)({ framework: features.framework, isProductionBuild })).filter(([expression]) => !Object.hasOwn(userDefine, expression))
+  );
+  if (Object.keys(define).length > 0) {
+    config.define = define;
+  }
+  const jsxImportSource = (0, import_obsidian_plugin_features.getJsxImportSource)(features.framework);
+  if (jsxImportSource !== void 0 && userConfig.oxc !== false && userConfig.oxc?.jsx === void 0) {
+    config.oxc = { jsx: { development: !isProductionBuild, importSource: jsxImportSource, runtime: "automatic" } };
+  }
+  if (postcssConfig && postcssConfig.plugins.length > 0 && userConfig.css?.postcss === void 0) {
+    config.css = { postcss: { plugins: [...postcssConfig.plugins] } };
+  }
+  return config;
+}
+function obsidianPluginVite(options = {}) {
+  const state = {
+    buildContext: void 0,
+    isDistFolderCleaned: false
+  };
+  function getBuildContext() {
+    if (!state.buildContext) {
+      throw new Error("The obsidian-plugin vite plugin has not resolved its build context: its `config` hook did not run.");
+    }
+    return state.buildContext;
+  }
+  const featurePlugin = (0, import_rollup_compatible_features.createRollupCompatibleFeaturePlugin)({
+    features: options,
+    isProductionBuild: () => getBuildContext().isProductionBuild,
+    shouldCompileStylesheets: false,
+    shouldReplaceDefines: false
+  });
+  const plugin = {
+    apply: "build",
+    async config(userConfig, env) {
+      state.buildContext = await (0, import_obsidian_plugin_build.resolveObsidianPluginBuildContext)({
+        ...options,
+        ...userConfig.build?.outDir !== void 0 && { distFolder: userConfig.build.outDir },
+        mode: options.mode ?? getViteBuildMode(userConfig, env)
+      });
+      const { isProductionBuild } = state.buildContext;
+      const postcssConfig = (0, import_obsidian_plugin_features.isPostcssNeeded)(options.styles) ? await (0, import_obsidian_plugin_transforms.loadPostcssConfig)({ isProductionBuild, styles: options.styles ?? {} }) : void 0;
+      const featureConfig = getViteFeatureConfig({ features: options, isProductionBuild, postcssConfig, userConfig });
+      const config = getViteConfigDefaults(userConfig, state.buildContext);
+      return { ...featureConfig, ...config };
+    },
+    generateBundle: {
+      handler(_outputOptions, bundle) {
+        (0, import_rollup_compatible.renameCssAssets)(this, bundle);
+      },
+      order: "post"
+    },
+    name: "obsidian-plugin",
+    async renderStart() {
+      if (state.isDistFolderCleaned) {
+        return;
+      }
+      state.isDistFolderCleaned = true;
+      await (0, import_obsidian_plugin_build.cleanObsidianPluginDistFolder)(getBuildContext().distFolder);
+    },
+    async writeBundle() {
+      await (0, import_obsidian_plugin_build.completeObsidianPluginDistFolder)(getBuildContext());
+      await (0, import_obsidian_plugins_folder_deployment.deployToObsidianPluginsFolder)(getBuildContext());
+    }
+  };
+  return [plugin, { ...featurePlugin, apply: "build" }, (0, import_rollup_compatible_features.createUnpluginVuePlugin)({ bundler: "vite", features: options })];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getViteBuildMode,
+  getViteConfigDefaults,
+  getViteFeatureConfig,
+  obsidianPluginVite
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/vite.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with vite: a vite plugin that turns `vite build` into a library build of\n * `src/main.ts` with the same `main.js` + `styles.css` + `manifest.json` layout the esbuild builder\n * produces, deploys a `vite build --watch` build into the vault, and fills in only the options the\n * consumer's own `vite.config` leaves unset.\n *\n * `vite` is an optional peer dependency and this module only imports its types, so a plugin built with\n * esbuild installs nothing extra.\n */\n\nimport type {\n  ConfigEnv,\n  Plugin,\n  PluginOption,\n  UserConfig\n} from 'vite';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\nimport type { PostcssConfig } from './obsidian-plugin-transforms.ts';\nimport type {\n  AssetEmitter,\n  BundleOutputLike\n} from './rollup-compatible.ts';\n\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport {\n  getFrameworkDefines,\n  getJsxImportSource,\n  isPostcssNeeded\n} from './obsidian-plugin-features.ts';\nimport { loadPostcssConfig } from './obsidian-plugin-transforms.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\nimport {\n  createRollupCompatibleFeaturePlugin,\n  createUnpluginVuePlugin\n} from './rollup-compatible-features.ts';\nimport {\n  combineExternal,\n  renameCssAssets\n} from './rollup-compatible.ts';\n\n/**\n * Parameters for {@link getViteFeatureConfig}.\n */\nexport interface GetViteFeatureConfigParams {\n  /**\n   * The build features.\n   */\n  readonly features: ObsidianPluginFeatureOptions;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The PostCSS plugins of the `styles` option, or `undefined` when it needs none.\n   */\n  readonly postcssConfig: PostcssConfig | undefined;\n\n  /**\n   * The consumer's vite config.\n   */\n  readonly userConfig: UserConfig;\n}\n\n/**\n * Options for {@link obsidianPluginVite}.\n */\nexport interface ObsidianPluginViteOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * The build mode. Defaults to {@link BuildMode.Development} for `vite build --watch` (or\n   * `--mode development`) and {@link BuildMode.Production} otherwise.\n   */\n  readonly mode?: BuildMode;\n}\n\n/**\n * The state one {@link obsidianPluginVite} instance keeps across the hooks of a build, and across the\n * rebuilds of a watch.\n */\ninterface ObsidianPluginViteState {\n  buildContext: ObsidianPluginBuildContext | undefined;\n  isDistFolderCleaned: boolean;\n}\n\n/**\n * Decides the build mode of a vite build from the consumer's config: development for a watch build or for\n * `--mode development`, production otherwise.\n *\n * @param userConfig - The consumer's vite config.\n * @param env - The vite config environment.\n * @returns The build mode.\n */\nexport function getViteBuildMode(userConfig: UserConfig, env: Pick<ConfigEnv, 'mode'>): BuildMode {\n  return userConfig.build?.watch || env.mode === 'development' ? BuildMode.Development : BuildMode.Production;\n}\n\n/**\n * Builds the part of the vite config the plugin contributes: only the options the consumer left unset.\n *\n * @param userConfig - The consumer's vite config.\n * @param buildContext - The build context.\n * @returns The config vite merges into the consumer's.\n */\nexport function getViteConfigDefaults(userConfig: UserConfig, buildContext: ObsidianPluginBuildContext): UserConfig {\n  const build = userConfig.build ?? {};\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- A consumer's config may still use the deprecated alias, and vite still honors it.\n  const rolldownOptions = build.rolldownOptions ?? build.rollupOptions ?? {};\n  const output = Array.isArray(rolldownOptions.output) ? undefined : rolldownOptions.output ?? {};\n\n  return {\n    build: {\n      // An Obsidian release ships `main.js` and `styles.css` and nothing else, so any asset emitted beside\n      // the bundle is a file the installed plugin looks for and does not find.\n      assetsInlineLimit: build.assetsInlineLimit ?? Number.MAX_SAFE_INTEGER,\n      // eslint-disable-next-line unicorn/name-replacements -- `emptyOutDir` is the name vite's config reads.\n      emptyOutDir: false,\n      lib: build.lib ?? {\n        cssFileName: 'styles',\n        entry: buildContext.entryPoint,\n        fileName: (): string => 'main.js',\n        formats: ['cjs']\n      },\n      minify: build.minify ?? buildContext.isProductionBuild,\n      // eslint-disable-next-line unicorn/name-replacements -- `outDir` is the name vite's config reads.\n      outDir: buildContext.distFolder,\n      rolldownOptions: {\n        external: combineExternal(rolldownOptions.external),\n        ...(output !== undefined && {\n          output: {\n            // `postBanner` rather than `banner`: it is added after minification, which strips an ordinary comment.\n            ...(output.banner === undefined && output.postBanner === undefined && { postBanner: getObsidianPluginBanner('vite') }),\n            // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.\n            // eslint-disable-next-line @typescript-eslint/no-deprecated -- A consumer's config may still set the deprecated option, which then wins.\n            ...(output.codeSplitting === undefined && output.inlineDynamicImports === undefined && { codeSplitting: false })\n          }\n        })\n      },\n      sourcemap: build.sourcemap ?? (!buildContext.isProductionBuild && 'inline')\n    }\n  };\n}\n\n/**\n * Builds the part of the vite config the build features contribute, each only where the consumer's config left it\n * unset: the framework's compile-time constants (`define`), the automatic JSX runtime for React and Preact\n * (`oxc.jsx`), and the PostCSS plugins of the `styles` option (`css.postcss`).\n *\n * @param params - The {@link GetViteFeatureConfigParams}.\n * @returns The config vite merges into the consumer's.\n */\nexport function getViteFeatureConfig(params: GetViteFeatureConfigParams): UserConfig {\n  const { features, isProductionBuild, postcssConfig, userConfig } = params;\n  const config: UserConfig = {};\n\n  const userDefine = userConfig.define ?? {};\n  const define = Object.fromEntries(\n    Object.entries(getFrameworkDefines({ framework: features.framework, isProductionBuild })).filter(([expression]) => !Object.hasOwn(userDefine, expression))\n  );\n  if (Object.keys(define).length > 0) {\n    config.define = define;\n  }\n\n  const jsxImportSource = getJsxImportSource(features.framework);\n  if (jsxImportSource !== undefined && userConfig.oxc !== false && userConfig.oxc?.jsx === undefined) {\n    config.oxc = { jsx: { development: !isProductionBuild, importSource: jsxImportSource, runtime: 'automatic' } };\n  }\n\n  if (postcssConfig && postcssConfig.plugins.length > 0 && userConfig.css?.postcss === undefined) {\n    config.css = { postcss: { plugins: [...postcssConfig.plugins] } };\n  }\n  return config;\n}\n\n/**\n * Creates a vite plugin that builds an Obsidian plugin.\n *\n * What it does, each only when the consumer's config has not said otherwise:\n *\n * - `build.lib` builds `src/main.ts` as one CommonJS `main.js`, with its CSS in `styles.css`.\n * - `build.outDir` is `dist/build` (`dist/dev` in development).\n * - `build.minify` is on in production only, and `build.sourcemap` is inline in development only.\n * - Every asset is inlined, because an Obsidian release ships `main.js` and `styles.css` and nothing else.\n * - Dynamic imports are inlined into `main.js`, and the generated-file banner heads it.\n *\n * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are\n * external beside the consumer's own `external`, the output folder is emptied once before the first write\n * (`build.emptyOutDir` is turned off, since this plugin does it), every emitted CSS file ends up in\n * `styles.css`, `manifest.json` (and in development `.hotreload`) is copied beside it, and a development\n * build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.\n *\n * The build features ({@link ObsidianPluginFeatureOptions}):\n *\n * - `framework: 'react' | 'preact'` sets `oxc.jsx` to the automatic runtime (unless set).\n * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds\n *   `unplugin-vue`.\n * - Any framework defines `process.env.NODE_ENV` (and Vue's feature flags), which a library build leaves alone.\n * - `styles.postcss` and `styles.tailwind` set `css.postcss` (unless set); vite scopes `*.module.css` itself, so\n *   `styles.cssModules` changes nothing here.\n * - `wasm` imports a `.wasm` module as its bytes.\n *\n * @param options - The {@link ObsidianPluginViteOptions}.\n * @returns The vite plugins, which vite takes as one entry of its `plugins`.\n */\nexport function obsidianPluginVite(options: ObsidianPluginViteOptions = {}): PluginOption[] {\n  const state: ObsidianPluginViteState = {\n    buildContext: undefined,\n    isDistFolderCleaned: false\n  };\n\n  /* v8 ignore start -- Vite hooks; exercised by the bundler integration test against a real vite build. */\n  function getBuildContext(): ObsidianPluginBuildContext {\n    if (!state.buildContext) {\n      throw new Error('The obsidian-plugin vite plugin has not resolved its build context: its `config` hook did not run.');\n    }\n    return state.buildContext;\n  }\n\n  const featurePlugin = createRollupCompatibleFeaturePlugin({\n    features: options,\n    isProductionBuild: () => getBuildContext().isProductionBuild,\n    shouldCompileStylesheets: false,\n    shouldReplaceDefines: false\n  });\n\n  const plugin = {\n    apply: 'build',\n    async config(userConfig: UserConfig, env: ConfigEnv): Promise<UserConfig> {\n      state.buildContext = await resolveObsidianPluginBuildContext({\n        ...options,\n        ...(userConfig.build?.outDir !== undefined && { distFolder: userConfig.build.outDir }),\n        mode: options.mode ?? getViteBuildMode(userConfig, env)\n      });\n      const { isProductionBuild } = state.buildContext;\n      const postcssConfig = isPostcssNeeded(options.styles)\n        ? await loadPostcssConfig({ isProductionBuild, styles: options.styles ?? {} })\n        : undefined;\n      const featureConfig = getViteFeatureConfig({ features: options, isProductionBuild, postcssConfig, userConfig });\n      const config = getViteConfigDefaults(userConfig, state.buildContext);\n      return { ...featureConfig, ...config };\n    },\n    generateBundle: {\n      handler(this: AssetEmitter, _outputOptions: unknown, bundle: Record<string, BundleOutputLike>): void {\n        renameCssAssets(this, bundle);\n      },\n      order: 'post'\n    },\n    name: 'obsidian-plugin',\n    async renderStart(): Promise<void> {\n      if (state.isDistFolderCleaned) {\n        return;\n      }\n      state.isDistFolderCleaned = true;\n      await cleanObsidianPluginDistFolder(getBuildContext().distFolder);\n    },\n    async writeBundle(): Promise<void> {\n      await completeObsidianPluginDistFolder(getBuildContext());\n      await deployToObsidianPluginsFolder(getBuildContext());\n    }\n  } as Plugin;\n  return [plugin, { ...featurePlugin, apply: 'build' } as Plugin, createUnpluginVuePlugin({ bundler: 'vite', features: options }) as Promise<null | Plugin>];\n  /* v8 ignore stop */\n}\n"],"mappings":"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","names":[]}