@mnaoumov/typescript-dev-toolkit 5.0.0 → 5.2.0

package/dist/lib/cjs/test-runners/vitest.cjs

@@ -2,11 +2,46 @@
 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();
+})();
 
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -20,6 +55,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var vitest_exports = {};
 __export(vitest_exports, {
@@ -28,9 +71,25 @@ __export(vitest_exports, {
   testWatch: () => testWatch
 });
 module.exports = __toCommonJS(vitest_exports);
+var import_node_os = require('node:os');
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+var import_bulk_concurrency = require('../bulk-concurrency.cjs');
 var import_root = require('../root.cjs');
+var import_forwarded_arguments = require('./forwarded-arguments.cjs');
+const WATCH_WORKER_DIVISOR = 2;
+const workerEnvironmentQueue = { pending: Promise.resolve(void 0) };
+const PROJECT_OPTION = { names: ["--project"], replacement: "the `projects` option" };
+const RUN_MODE_OPTION = { names: ["--run", "--watch", "-w"], replacement: "the `test`, `testCoverage` or `testWatch` wrapper" };
+const COVERAGE_OPTION = {
+  names: ["--coverage", "--no-coverage"],
+  prefixes: ["--coverage."],
+  replacement: "the `testCoverage` wrapper and its `minCoverageInPercents` option"
+};
+const OWNED_OPTIONS = [PROJECT_OPTION, RUN_MODE_OPTION, COVERAGE_OPTION];
 async function test(options = {}) {
-  await (0, import_root.execFromRoot)(["vitest", "run", ...buildProjectFlags(options.projects)]);
+  await (0, import_root.execFromRoot)(["vitest", "run", ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {
+    env: await getWorkerEnvironment(options)
+  });
 }
 async function testCoverage(options = {}) {
   const threshold = String(options.minCoverageInPercents ?? 0);
@@ -42,19 +101,66 @@ async function testCoverage(options = {}) {
     `--coverage.thresholds.lines=${threshold}`,
     `--coverage.thresholds.functions=${threshold}`,
     `--coverage.thresholds.branches=${threshold}`,
-    `--coverage.thresholds.statements=${threshold}`
-  ]);
+    `--coverage.thresholds.statements=${threshold}`,
+    ...getAdditionalArguments(options)
+  ], { env: await getWorkerEnvironment(options) });
 }
 async function testWatch(options = {}) {
-  await (0, import_root.execFromRoot)(["vitest", ...buildProjectFlags(options.projects)]);
+  await (0, import_root.execFromRoot)(["vitest", ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {
+    env: await getWorkerEnvironment(options, true)
+  });
 }
 function buildProjectFlags(projects) {
   return (projects ?? []).flatMap((project) => [`--project=${project}`, `--project=${project}:*`]);
 }
+function getAdditionalArguments(options) {
+  const { additionalArguments = [] } = options;
+  (0, import_forwarded_arguments.assertNoOwnedArguments)({ forwardedArguments: additionalArguments, ownedOptions: OWNED_OPTIONS, runnerName: "vitest" });
+  return additionalArguments;
+}
+async function getWorkerEnvironment(options, isWatch = false) {
+  const next = workerEnvironmentQueue.pending.then(() => resolveWorkerEnvironment(options, isWatch));
+  workerEnvironmentQueue.pending = next.catch(() => void 0);
+  return next;
+}
+async function resolveWorkerEnvironment(options, isWatch) {
+  const budget = (0, import_bulk_concurrency.getBulkConcurrency)(Infinity);
+  if (!Number.isFinite(budget)) {
+    return {};
+  }
+  const { resolveConfig } = await import("vitest/node");
+  const inheritedWorkers = import_node_process.default.env["VITEST_MAX_WORKERS"];
+  delete import_node_process.default.env["VITEST_MAX_WORKERS"];
+  let config;
+  try {
+    config = await resolveConfig({
+      project: (options.projects ?? []).flatMap((project) => [project, `${project}:*`]),
+      root: (0, import_root.resolvePathFromRootSafe)({ path: "." }),
+      watch: isWatch
+    });
+  } finally {
+    if (inheritedWorkers !== void 0) {
+      import_node_process.default.env["VITEST_MAX_WORKERS"] = inheritedWorkers;
+    }
+  }
+  const ordinaryWorkers = Math.max(isWatch ? Math.floor((0, import_node_os.availableParallelism)() / WATCH_WORKER_DIVISOR) : (0, import_node_os.availableParallelism)() - 1, 1);
+  const inheritedLimit = Number.parseInt(inheritedWorkers ?? "", 10);
+  let workers = Math.min(budget, ordinaryWorkers);
+  if (Number.isSafeInteger(inheritedLimit) && inheritedLimit > 0) {
+    workers = Math.min(workers, inheritedLimit);
+  }
+  const configs = [config.test, ...config.test.resolvedProjects.filter((entry) => !entry.hidden).map((entry) => entry.projectConfig)];
+  for (const testConfig of configs) {
+    if (testConfig.maxWorkers) {
+      workers = Math.min(workers, testConfig.maxWorkers);
+    }
+  }
+  return { VITEST_MAX_WORKERS: String(workers) };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   test,
   testCoverage,
   testWatch
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/test-runners/vitest.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides functions for running tests using the Vitest framework.\n */\n\nimport { availableParallelism } from 'node:os';\nimport process from 'node:process';\n\nimport type { OwnedOption } from './forwarded-arguments.ts';\n\nimport { getBulkConcurrency } from '../bulk-concurrency.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport { assertNoOwnedArguments } from './forwarded-arguments.ts';\n\nconst WATCH_WORKER_DIVISOR = 2;\nconst workerEnvironmentQueue = { pending: Promise.resolve<unknown>(undefined) };\n\nconst PROJECT_OPTION: OwnedOption = { names: ['--project'], replacement: 'the `projects` option' };\nconst RUN_MODE_OPTION: OwnedOption = { names: ['--run', '--watch', '-w'], replacement: 'the `test`, `testCoverage` or `testWatch` wrapper' };\nconst COVERAGE_OPTION: OwnedOption = {\n  names: ['--coverage', '--no-coverage'],\n  prefixes: ['--coverage.'],\n  replacement: 'the `testCoverage` wrapper and its `minCoverageInPercents` option'\n};\nconst OWNED_OPTIONS: readonly OwnedOption[] = [PROJECT_OPTION, RUN_MODE_OPTION, COVERAGE_OPTION];\n\n/**\n * Options for running tests with coverage.\n */\nexport interface TestCoverageOptions extends TestOptions {\n  /**\n   * Minimum coverage percentage required. If the actual coverage falls below\n   * this threshold, the process exits with a non-zero code.\n   *\n   * @default `0`\n   */\n  readonly minCoverageInPercents?: number;\n}\n\n/**\n * Options for running tests.\n */\nexport interface TestOptions {\n  /**\n   * Further vitest CLI arguments, appended after the wrapper's own: file filters, `-t`, `--maxWorkers`, `--reporter`.\n   * An argument naming an option the wrapper sets itself (`--project`, `--coverage*`, `--run`, `--watch`) throws.\n   */\n  readonly additionalArguments?: readonly string[];\n\n  /**\n   * The projects to run.\n   */\n  readonly projects?: string[];\n}\n\n/**\n * Options for running tests in watch mode.\n */\nexport type TestWatchOptions = TestOptions;\n\n/**\n * Runs the test suite.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function test(options: TestOptions = {}): Promise<void> {\n  await execFromRoot(['vitest', 'run', ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {\n    env: await getWorkerEnvironment(options)\n  });\n}\n\n/**\n * Runs the test suite with coverage.\n *\n * @param options - Optional coverage configuration.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testCoverage(options: TestCoverageOptions = {}): Promise<void> {\n  const threshold = String(options.minCoverageInPercents ?? 0);\n  await execFromRoot([\n    'vitest',\n    'run',\n    ...buildProjectFlags(options.projects),\n    '--coverage',\n    `--coverage.thresholds.lines=${threshold}`,\n    `--coverage.thresholds.functions=${threshold}`,\n    `--coverage.thresholds.branches=${threshold}`,\n    `--coverage.thresholds.statements=${threshold}`,\n    ...getAdditionalArguments(options)\n  ], { env: await getWorkerEnvironment(options) });\n}\n\n/**\n * Runs the test suite in watch mode.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testWatch(options: TestWatchOptions = {}): Promise<void> {\n  await execFromRoot(['vitest', ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {\n    env: await getWorkerEnvironment(options, true)\n  });\n}\n\n/**\n * Builds `--project` flags for the given project prefixes.\n * Each prefix expands to both `--project=prefix` (exact match)\n * and `--project=prefix:*` (sub-projects).\n *\n * @param projects - The project name prefixes.\n * @returns The `--project` flags array.\n */\nfunction buildProjectFlags(projects?: string[]): string[] {\n  return (projects ?? []).flatMap((project) => [`--project=${project}`, `--project=${project}:*`]);\n}\n\n/**\n * Checks the forwarded arguments against the options the wrappers set themselves.\n *\n * @param options - The options for the test.\n * @returns The forwarded arguments.\n */\nfunction getAdditionalArguments(options: TestOptions): readonly string[] {\n  const { additionalArguments = [] } = options;\n  assertNoOwnedArguments({ forwardedArguments: additionalArguments, ownedOptions: OWNED_OPTIONS, runnerName: 'vitest' });\n  return additionalArguments;\n}\n\n/**\n * Resolves the bulk cap without letting Vitest's environment override hide narrower project limits.\n * The narrowest limit applies to the whole invocation because CLI and environment limits replace project limits.\n *\n * @param options - The selected test projects.\n * @param isWatch - Whether this invocation watches for changes.\n * @returns Child environment overrides, empty outside bulk work.\n */\nasync function getWorkerEnvironment(options: TestOptions, isWatch = false): Promise<NodeJS.ProcessEnv> {\n  const next = workerEnvironmentQueue.pending.then(() => resolveWorkerEnvironment(options, isWatch));\n  workerEnvironmentQueue.pending = next.catch(() => undefined);\n  return next;\n}\n\n/**\n * Resolves one invocation's worker environment while holding the configuration-resolution queue.\n *\n * @param options - The selected test projects.\n * @param isWatch - Whether this invocation watches for changes.\n * @returns Child environment overrides.\n */\nasync function resolveWorkerEnvironment(options: TestOptions, isWatch: boolean): Promise<NodeJS.ProcessEnv> {\n  const budget = getBulkConcurrency(Infinity);\n  if (!Number.isFinite(budget)) {\n    return {};\n  }\n\n  // Optional peer: leave loading Vitest to the CLI outside bulk work.\n  const { resolveConfig } = await import('vitest/node');\n  const inheritedWorkers = process.env['VITEST_MAX_WORKERS'];\n  delete process.env['VITEST_MAX_WORKERS'];\n  let config;\n  try {\n    config = await resolveConfig({\n      project: (options.projects ?? []).flatMap((project) => [project, `${project}:*`]),\n      root: resolvePathFromRootSafe({ path: '.' }),\n      watch: isWatch\n    });\n  } finally {\n    if (inheritedWorkers !== undefined) {\n      // eslint-disable-next-line require-atomic-updates -- Worker environment resolutions are serialized; restore the inherited value before the next invocation reads it.\n      process.env['VITEST_MAX_WORKERS'] = inheritedWorkers;\n    }\n  }\n\n  const ordinaryWorkers = Math.max(isWatch ? Math.floor(availableParallelism() / WATCH_WORKER_DIVISOR) : availableParallelism() - 1, 1);\n  const inheritedLimit = Number.parseInt(inheritedWorkers ?? '', 10);\n  let workers = Math.min(budget, ordinaryWorkers);\n  if (Number.isSafeInteger(inheritedLimit) && inheritedLimit > 0) {\n    workers = Math.min(workers, inheritedLimit);\n  }\n\n  const configs = [config.test, ...config.test.resolvedProjects.filter((entry) => !entry.hidden).map((entry) => entry.projectConfig)];\n  for (const testConfig of configs) {\n    if (testConfig.maxWorkers) {\n      workers = Math.min(workers, testConfig.maxWorkers);\n    }\n  }\n\n  return { VITEST_MAX_WORKERS: String(workers) };\n}\n"],"mappings":"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","names":["process"]}

package/dist/lib/cjs/test-runners/vitest.d.cts

@@ -20,6 +20,11 @@ export interface TestCoverageOptions extends TestOptions {
  * Options for running tests.
  */
 export interface TestOptions {
+    /**
+     * Further vitest CLI arguments, appended after the wrapper's own: file filters, `-t`, `--maxWorkers`, `--reporter`.
+     * An argument naming an option the wrapper sets itself (`--project`, `--coverage*`, `--run`, `--watch`) throws.
+     */
+    readonly additionalArguments?: readonly string[];
     /**
      * The projects to run.
      */

package/dist/lib/esm/bulk-concurrency.d.mts

@@ -0,0 +1,14 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Caps tool concurrency to the bulk worker's processor budget.
+ */
+/**
+ * Caps a tool's ordinary concurrency when `BULK_CORES` names a positive safe integer.
+ * Missing or malformed budgets leave the ordinary default unchanged. Reads the environment on each call.
+ *
+ * @param defaultConcurrency - The tool's ordinary positive concurrency limit.
+ * @returns The default capped by the valid bulk budget, or the unchanged default.
+ */
+export declare function getBulkConcurrency(defaultConcurrency: number): number;

package/dist/lib/esm/bulk-concurrency.mjs

@@ -0,0 +1,15 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import process from "node:process";
+function getBulkConcurrency(defaultConcurrency) {
+  const budget = process.env["BULK_CORES"]?.trim() ?? "";
+  const cores = Number(budget);
+  return /^[1-9]\d*$/.test(budget) && Number.isSafeInteger(cores) ? Math.min(defaultConcurrency, cores) : defaultConcurrency;
+}
+export {
+  getBulkConcurrency
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2J1bGstY29uY3VycmVuY3kudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDYXBzIHRvb2wgY29uY3VycmVuY3kgdG8gdGhlIGJ1bGsgd29ya2VyJ3MgcHJvY2Vzc29yIGJ1ZGdldC5cbiAqL1xuXG5pbXBvcnQgcHJvY2VzcyBmcm9tICdub2RlOnByb2Nlc3MnO1xuXG4vKipcbiAqIENhcHMgYSB0b29sJ3Mgb3JkaW5hcnkgY29uY3VycmVuY3kgd2hlbiBgQlVMS19DT1JFU2AgbmFtZXMgYSBwb3NpdGl2ZSBzYWZlIGludGVnZXIuXG4gKiBNaXNzaW5nIG9yIG1hbGZvcm1lZCBidWRnZXRzIGxlYXZlIHRoZSBvcmRpbmFyeSBkZWZhdWx0IHVuY2hhbmdlZC4gUmVhZHMgdGhlIGVudmlyb25tZW50IG9uIGVhY2ggY2FsbC5cbiAqXG4gKiBAcGFyYW0gZGVmYXVsdENvbmN1cnJlbmN5IC0gVGhlIHRvb2wncyBvcmRpbmFyeSBwb3NpdGl2ZSBjb25jdXJyZW5jeSBsaW1pdC5cbiAqIEByZXR1cm5zIFRoZSBkZWZhdWx0IGNhcHBlZCBieSB0aGUgdmFsaWQgYnVsayBidWRnZXQsIG9yIHRoZSB1bmNoYW5nZWQgZGVmYXVsdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEJ1bGtDb25jdXJyZW5jeShkZWZhdWx0Q29uY3VycmVuY3k6IG51bWJlcik6IG51bWJlciB7XG4gIGNvbnN0IGJ1ZGdldCA9IHByb2Nlc3MuZW52WydCVUxLX0NPUkVTJ10/LnRyaW0oKSA/PyAnJztcbiAgY29uc3QgY29yZXMgPSBOdW1iZXIoYnVkZ2V0KTtcbiAgcmV0dXJuIC9eWzEtOV1cXGQqJC8udGVzdChidWRnZXQpICYmIE51bWJlci5pc1NhZmVJbnRlZ2VyKGNvcmVzKVxuICAgID8gTWF0aC5taW4oZGVmYXVsdENvbmN1cnJlbmN5LCBjb3JlcylcbiAgICA6IGRlZmF1bHRDb25jdXJyZW5jeTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBTUEsT0FBTyxhQUFhO0FBU2IsU0FBUyxtQkFBbUIsb0JBQW9DO0FBQ3JFLFFBQU0sU0FBUyxRQUFRLElBQUksWUFBWSxHQUFHLEtBQUssS0FBSztBQUNwRCxRQUFNLFFBQVEsT0FBTyxNQUFNO0FBQzNCLFNBQU8sYUFBYSxLQUFLLE1BQU0sS0FBSyxPQUFPLGNBQWMsS0FBSyxJQUMxRCxLQUFLLElBQUksb0JBQW9CLEtBQUssSUFDbEM7QUFDTjsiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -3,4 +3,5 @@ export * as 'change-extension-plugin' from './change-extension-plugin.mjs';
 export * as 'custom-esbuild-options-plugin' from './custom-esbuild-options-plugin.mjs';
 export * as 'fix-esm-plugin' from './fix-esm-plugin.mjs';
 export * as 'preprocess-plugin' from './preprocess-plugin.mjs';
+export * as 'svelte-preprocessor' from './svelte-preprocessor.mjs';
 export * as 'svelte-wrapper-plugin' from './svelte-wrapper-plugin.mjs';

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

@@ -7,12 +7,14 @@ import * as change_extension_plugin from "./change-extension-plugin.mjs";
 import * as custom_esbuild_options_plugin from "./custom-esbuild-options-plugin.mjs";
 import * as fix_esm_plugin from "./fix-esm-plugin.mjs";
 import * as preprocess_plugin from "./preprocess-plugin.mjs";
+import * as svelte_preprocessor from "./svelte-preprocessor.mjs";
 import * as svelte_wrapper_plugin from "./svelte-wrapper-plugin.mjs";
 export {
   change_extension_plugin as "change-extension-plugin",
   custom_esbuild_options_plugin as "custom-esbuild-options-plugin",
   fix_esm_plugin as "fix-esm-plugin",
   preprocess_plugin as "preprocess-plugin",
+  svelte_preprocessor as "svelte-preprocessor",
   svelte_wrapper_plugin as "svelte-wrapper-plugin"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2J1bmRsZXJzL2VzYnVpbGQtaW1wbC9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdjaGFuZ2UtZXh0ZW5zaW9uLXBsdWdpbicgZnJvbSAnLi9jaGFuZ2UtZXh0ZW5zaW9uLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnY3VzdG9tLWVzYnVpbGQtb3B0aW9ucy1wbHVnaW4nIGZyb20gJy4vY3VzdG9tLWVzYnVpbGQtb3B0aW9ucy1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ2ZpeC1lc20tcGx1Z2luJyBmcm9tICcuL2ZpeC1lc20tcGx1Z2luLnRzJztcbmV4cG9ydCAqIGFzICdwcmVwcm9jZXNzLXBsdWdpbicgZnJvbSAnLi9wcmVwcm9jZXNzLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc3ZlbHRlLXdyYXBwZXItcGx1Z2luJyBmcm9tICcuL3N2ZWx0ZS13cmFwcGVyLXBsdWdpbi50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVlBLDZCQUErQjtBQUMzQyxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMsb0JBQXNCO0FBQ2xDLFlBQVlDLHVCQUF5QjtBQUNyQyxZQUFZQywyQkFBNkI7IiwKICAibmFtZXMiOiBbImNoYW5nZS1leHRlbnNpb24tcGx1Z2luIiwgImN1c3RvbS1lc2J1aWxkLW9wdGlvbnMtcGx1Z2luIiwgImZpeC1lc20tcGx1Z2luIiwgInByZXByb2Nlc3MtcGx1Z2luIiwgInN2ZWx0ZS13cmFwcGVyLXBsdWdpbiJdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2J1bmRsZXJzL2VzYnVpbGQtaW1wbC9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdjaGFuZ2UtZXh0ZW5zaW9uLXBsdWdpbicgZnJvbSAnLi9jaGFuZ2UtZXh0ZW5zaW9uLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnY3VzdG9tLWVzYnVpbGQtb3B0aW9ucy1wbHVnaW4nIGZyb20gJy4vY3VzdG9tLWVzYnVpbGQtb3B0aW9ucy1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ2ZpeC1lc20tcGx1Z2luJyBmcm9tICcuL2ZpeC1lc20tcGx1Z2luLnRzJztcbmV4cG9ydCAqIGFzICdwcmVwcm9jZXNzLXBsdWdpbicgZnJvbSAnLi9wcmVwcm9jZXNzLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc3ZlbHRlLXByZXByb2Nlc3NvcicgZnJvbSAnLi9zdmVsdGUtcHJlcHJvY2Vzc29yLnRzJztcbmV4cG9ydCAqIGFzICdzdmVsdGUtd3JhcHBlci1wbHVnaW4nIGZyb20gJy4vc3ZlbHRlLXdyYXBwZXItcGx1Z2luLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsNkJBQStCO0FBQzNDLFlBQVlDLG1DQUFxQztBQUNqRCxZQUFZQyxvQkFBc0I7QUFDbEMsWUFBWUMsdUJBQXlCO0FBQ3JDLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZQywyQkFBNkI7IiwKICAibmFtZXMiOiBbImNoYW5nZS1leHRlbnNpb24tcGx1Z2luIiwgImN1c3RvbS1lc2J1aWxkLW9wdGlvbnMtcGx1Z2luIiwgImZpeC1lc20tcGx1Z2luIiwgInByZXByb2Nlc3MtcGx1Z2luIiwgInN2ZWx0ZS1wcmVwcm9jZXNzb3IiLCAic3ZlbHRlLXdyYXBwZXItcGx1Z2luIl0KfQo=

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

@@ -0,0 +1,95 @@
+/// <reference path="../../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Svelte preprocessor that compiles TypeScript scripts with esbuild.
+ *
+ * It replaces `svelte-preprocess` for the one language every Svelte component of these projects uses, `lang="ts"`, so
+ * the toolkit no longer depends on `svelte-preprocess`, whose optional `@babel/core` 7 peer conflicts with the Babel 8
+ * that Stryker installs. Any other script or style language is handed to `svelte-preprocess`, an optional peer, when the
+ * project installs it.
+ */
+/**
+ * The attributes of a `<script>` or `<style>` block.
+ */
+export type SvelteBlockAttributes = Record<string, boolean | string>;
+/**
+ * A Svelte preprocessor for one kind of block.
+ */
+export type SvelteBlockPreprocessor = (params: SveltePreprocessorParams) => Promise<SveltePreprocessorResult | undefined>;
+/**
+ * A Svelte preprocessor group, in the shape `svelte/compiler`'s `preprocess` takes.
+ */
+export interface SveltePreprocessorGroup {
+    /**
+     * The name of the group.
+     */
+    readonly name: string;
+    /**
+     * The preprocessor of `<script>` blocks.
+     */
+    readonly script: SvelteBlockPreprocessor;
+    /**
+     * The preprocessor of `<style>` blocks.
+     */
+    readonly style: SvelteBlockPreprocessor;
+}
+/**
+ * What a Svelte preprocessor is given for one `<script>` or `<style>` block.
+ */
+export interface SveltePreprocessorParams {
+    /**
+     * The attributes of the block.
+     */
+    readonly attributes: SvelteBlockAttributes;
+    /**
+     * The content of the block.
+     */
+    readonly content: string;
+    /**
+     * The path of the component.
+     */
+    readonly filename?: string;
+    /**
+     * The whole component.
+     */
+    readonly markup: string;
+}
+/**
+ * What a Svelte preprocessor returns for a block it changed.
+ */
+export interface SveltePreprocessorResult {
+    /**
+     * The new content of the block.
+     */
+    readonly code: string;
+    /**
+     * The source map of the change.
+     */
+    readonly map?: object | string;
+}
+/**
+ * Creates the Svelte preprocessor the toolkit's esbuild build uses.
+ *
+ * A `<script lang="ts">` block is transpiled with esbuild under `verbatimModuleSyntax`, as Svelte's own `vitePreprocess`
+ * does, so an import that only the markup uses is kept and a type import must say `import type`. A plain script or
+ * style block is left alone. Any other language is handed to `svelte-preprocess`, loaded only then; when the project
+ * does not install it, preprocessing that block fails naming the package.
+ *
+ * @returns The preprocessor group.
+ */
+export declare function createSveltePreprocessor(): SveltePreprocessorGroup;
+/**
+ * Gets the language of a `<script>` or `<style>` block from its `lang` attribute, or else its `type` attribute.
+ *
+ * @param attributes - The attributes of the block.
+ * @returns The language, lowercased, or `undefined` when the block names none.
+ */
+export declare function getBlockLanguage(attributes: SvelteBlockAttributes): string | undefined;
+/**
+ * Checks whether an error is the one loading `svelte-preprocess` throws when the project does not install it.
+ *
+ * @param error - The error to check.
+ * @returns Whether the error says that the `svelte-preprocess` package cannot be found.
+ */
+export declare function isMissingSveltePreprocessError(error: unknown): boolean;

package/dist/lib/esm/bundlers/esbuild-impl/svelte-preprocessor.mjs

@@ -0,0 +1,126 @@
+/*
+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();
+})();
+
+import { transform } from "esbuild";
+const SVELTE_PREPROCESS_PACKAGE_NAME = "svelte-preprocess";
+const JAVASCRIPT_LANGUAGES = /* @__PURE__ */ new Set(["javascript", "js"]);
+const MISSING_SVELTE_PREPROCESS_MESSAGE_REG_EXP = /Cannot find (?:module|package) 'svelte-preprocess'/;
+const MODULE_NOT_FOUND_CODES = /* @__PURE__ */ new Set(["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"]);
+const TEXT_TYPE_PREFIX = "text/";
+const TYPESCRIPT_LANGUAGES = /* @__PURE__ */ new Set(["ts", "typescript"]);
+function createSveltePreprocessor() {
+  let fallbackPromise;
+  async function getFallbackPreprocessorGroup() {
+    fallbackPromise ??= loadFallbackPreprocessorGroup().catch((error) => {
+      fallbackPromise = void 0;
+      throw error;
+    });
+    return await fallbackPromise;
+  }
+  async function preprocessWithFallback(kind, language, params) {
+    let fallback;
+    try {
+      fallback = await getFallbackPreprocessorGroup();
+    } catch (error) {
+      if (!isMissingSveltePreprocessError(error)) {
+        throw error;
+      }
+      throw new Error(
+        `Cannot preprocess the <${kind} lang="${language}"> block of ${params.filename ?? "a Svelte component"}: install \`svelte-preprocess\` in the project to compile ${language}.`,
+        { cause: error }
+      );
+    }
+    return await fallback[kind]?.(params) ?? void 0;
+  }
+  return {
+    name: "typescript-dev-toolkit-svelte",
+    async script(params) {
+      const language = getBlockLanguage(params.attributes);
+      if (language === void 0 || JAVASCRIPT_LANGUAGES.has(language)) {
+        return void 0;
+      }
+      return TYPESCRIPT_LANGUAGES.has(language) ? await transpileTypeScript(params) : await preprocessWithFallback("script", language, params);
+    },
+    async style(params) {
+      const language = getBlockLanguage(params.attributes);
+      return language === void 0 || language === "css" ? void 0 : await preprocessWithFallback("style", language, params);
+    }
+  };
+}
+function getBlockLanguage(attributes) {
+  const lang = attributes["lang"];
+  if (typeof lang === "string" && lang !== "") {
+    return lang.toLowerCase();
+  }
+  const type = attributes["type"];
+  return typeof type === "string" && type.toLowerCase().startsWith(TEXT_TYPE_PREFIX) ? type.slice(TEXT_TYPE_PREFIX.length).toLowerCase() : void 0;
+}
+function isMissingSveltePreprocessError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return typeof code === "string" && MODULE_NOT_FOUND_CODES.has(code) && MISSING_SVELTE_PREPROCESS_MESSAGE_REG_EXP.test(error.message);
+}
+async function loadFallbackPreprocessorGroup() {
+  const svelteFallbackModule = await import(SVELTE_PREPROCESS_PACKAGE_NAME);
+  return svelteFallbackModule.sveltePreprocess();
+}
+async function transpileTypeScript(params) {
+  const result = await transform(params.content, {
+    loader: "ts",
+    sourcefile: params.filename ?? "",
+    sourcemap: "external",
+    target: "esnext",
+    tsconfigRaw: {
+      compilerOptions: {
+        verbatimModuleSyntax: true
+      }
+    }
+  });
+  return {
+    code: result.code,
+    map: result.map
+  };
+}
+export {
+  createSveltePreprocessor,
+  getBlockLanguage,
+  isMissingSveltePreprocessError
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/bundlers/esbuild-impl/svelte-preprocessor.ts"],"sourcesContent":["/**\n * @file\n *\n * Svelte preprocessor that compiles TypeScript scripts with esbuild.\n *\n * It replaces `svelte-preprocess` for the one language every Svelte component of these projects uses, `lang=\"ts\"`, so\n * the toolkit no longer depends on `svelte-preprocess`, whose optional `@babel/core` 7 peer conflicts with the Babel 8\n * that Stryker installs. Any other script or style language is handed to `svelte-preprocess`, an optional peer, when the\n * project installs it.\n */\n\nimport { transform } from 'esbuild';\n\n/**\n * The attributes of a `<script>` or `<style>` block.\n */\nexport type SvelteBlockAttributes = Record<string, boolean | string>;\n\n/**\n * A Svelte preprocessor for one kind of block.\n */\nexport type SvelteBlockPreprocessor = (params: SveltePreprocessorParams) => Promise<SveltePreprocessorResult | undefined>;\n\n/**\n * A Svelte preprocessor group, in the shape `svelte/compiler`'s `preprocess` takes.\n */\nexport interface SveltePreprocessorGroup {\n  /**\n   * The name of the group.\n   */\n  readonly name: string;\n\n  /**\n   * The preprocessor of `<script>` blocks.\n   */\n  readonly script: SvelteBlockPreprocessor;\n\n  /**\n   * The preprocessor of `<style>` blocks.\n   */\n  readonly style: SvelteBlockPreprocessor;\n}\n\n/**\n * What a Svelte preprocessor is given for one `<script>` or `<style>` block.\n */\nexport interface SveltePreprocessorParams {\n  /**\n   * The attributes of the block.\n   */\n  readonly attributes: SvelteBlockAttributes;\n\n  /**\n   * The content of the block.\n   */\n  readonly content: string;\n\n  /**\n   * The path of the component.\n   */\n  readonly filename?: string;\n\n  /**\n   * The whole component.\n   */\n  readonly markup: string;\n}\n\n/**\n * What a Svelte preprocessor returns for a block it changed.\n */\nexport interface SveltePreprocessorResult {\n  /**\n   * The new content of the block.\n   */\n  readonly code: string;\n\n  /**\n   * The source map of the change.\n   */\n  readonly map?: object | string;\n}\n\ntype BlockKind = 'script' | 'style';\n\ntype FallbackPreprocessorGroup = Partial<Record<BlockKind, (params: SveltePreprocessorParams) => unknown>>;\n\ninterface SveltePreprocessModule {\n  readonly sveltePreprocess: () => FallbackPreprocessorGroup;\n}\n\nconst SVELTE_PREPROCESS_PACKAGE_NAME = 'svelte-preprocess';\n\nconst JAVASCRIPT_LANGUAGES = new Set(['javascript', 'js']);\nconst MISSING_SVELTE_PREPROCESS_MESSAGE_REG_EXP = /Cannot find (?:module|package) 'svelte-preprocess'/;\nconst MODULE_NOT_FOUND_CODES = new Set(['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND']);\nconst TEXT_TYPE_PREFIX = 'text/';\nconst TYPESCRIPT_LANGUAGES = new Set(['ts', 'typescript']);\n\n/**\n * Creates the Svelte preprocessor the toolkit's esbuild build uses.\n *\n * A `<script lang=\"ts\">` block is transpiled with esbuild under `verbatimModuleSyntax`, as Svelte's own `vitePreprocess`\n * does, so an import that only the markup uses is kept and a type import must say `import type`. A plain script or\n * style block is left alone. Any other language is handed to `svelte-preprocess`, loaded only then; when the project\n * does not install it, preprocessing that block fails naming the package.\n *\n * @returns The preprocessor group.\n */\nexport function createSveltePreprocessor(): SveltePreprocessorGroup {\n  let fallbackPromise: Promise<FallbackPreprocessorGroup> | undefined;\n\n  // A failed load is forgotten, so a block after the project installs the package tries again.\n  async function getFallbackPreprocessorGroup(): Promise<FallbackPreprocessorGroup> {\n    fallbackPromise ??= loadFallbackPreprocessorGroup().catch((error: unknown) => {\n      fallbackPromise = undefined;\n      throw error;\n    });\n    return await fallbackPromise;\n  }\n\n  async function preprocessWithFallback(kind: BlockKind, language: string, params: SveltePreprocessorParams): Promise<SveltePreprocessorResult | undefined> {\n    let fallback: FallbackPreprocessorGroup;\n    try {\n      fallback = await getFallbackPreprocessorGroup();\n    } catch (error) {\n      if (!isMissingSveltePreprocessError(error)) {\n        throw error;\n      }\n      throw new Error(\n        `Cannot preprocess the <${kind} lang=\"${language}\"> block of ${params.filename ?? 'a Svelte component'}: install \\`svelte-preprocess\\` in the project to compile ${language}.`,\n        { cause: error }\n      );\n    }\n    return await fallback[kind]?.(params) as SveltePreprocessorResult | undefined ?? undefined;\n  }\n\n  return {\n    name: 'typescript-dev-toolkit-svelte',\n    async script(params): Promise<SveltePreprocessorResult | undefined> {\n      const language = getBlockLanguage(params.attributes);\n      if (language === undefined || JAVASCRIPT_LANGUAGES.has(language)) {\n        return undefined;\n      }\n      return TYPESCRIPT_LANGUAGES.has(language) ? (await transpileTypeScript(params)) : (await preprocessWithFallback('script', language, params));\n    },\n    async style(params): Promise<SveltePreprocessorResult | undefined> {\n      const language = getBlockLanguage(params.attributes);\n      return language === undefined || language === 'css' ? undefined : (await preprocessWithFallback('style', language, params));\n    }\n  };\n}\n\n/**\n * Gets the language of a `<script>` or `<style>` block from its `lang` attribute, or else its `type` attribute.\n *\n * @param attributes - The attributes of the block.\n * @returns The language, lowercased, or `undefined` when the block names none.\n */\nexport function getBlockLanguage(attributes: SvelteBlockAttributes): string | undefined {\n  const lang = attributes['lang'];\n  if (typeof lang === 'string' && lang !== '') {\n    return lang.toLowerCase();\n  }\n\n  const type = attributes['type'];\n  return typeof type === 'string' && type.toLowerCase().startsWith(TEXT_TYPE_PREFIX) ? type.slice(TEXT_TYPE_PREFIX.length).toLowerCase() : undefined;\n}\n\n/**\n * Checks whether an error is the one loading `svelte-preprocess` throws when the project does not install it.\n *\n * @param error - The error to check.\n * @returns Whether the error says that the `svelte-preprocess` package cannot be found.\n */\nexport function isMissingSveltePreprocessError(error: unknown): boolean {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  const code = (error as Partial<Record<'code', unknown>>).code;\n  return typeof code === 'string' && MODULE_NOT_FOUND_CODES.has(code) && MISSING_SVELTE_PREPROCESS_MESSAGE_REG_EXP.test(error.message);\n}\n\nasync function loadFallbackPreprocessorGroup(): Promise<FallbackPreprocessorGroup> {\n  /*\n   * The specifier is a variable so that type-checking does not need the package: installing it here would bring back the\n   * `@babel/core` peer conflict with Stryker this module exists to avoid.\n   */\n  const svelteFallbackModule = await import(SVELTE_PREPROCESS_PACKAGE_NAME) as SveltePreprocessModule;\n  return svelteFallbackModule.sveltePreprocess();\n}\n\nasync function transpileTypeScript(params: SveltePreprocessorParams): Promise<SveltePreprocessorResult> {\n  const result = await transform(params.content, {\n    loader: 'ts',\n    sourcefile: params.filename ?? '',\n    sourcemap: 'external',\n    target: 'esnext',\n    tsconfigRaw: {\n      compilerOptions: {\n        verbatimModuleSyntax: true\n      }\n    }\n  });\n  return {\n    code: result.code,\n    map: result.map\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,SAAS,iBAAiB;AAgF1B,MAAM,iCAAiC;AAEvC,MAAM,uBAAuB,oBAAI,IAAI,CAAC,cAAc,IAAI,CAAC;AACzD,MAAM,4CAA4C;AAClD,MAAM,yBAAyB,oBAAI,IAAI,CAAC,wBAAwB,kBAAkB,CAAC;AACnF,MAAM,mBAAmB;AACzB,MAAM,uBAAuB,oBAAI,IAAI,CAAC,MAAM,YAAY,CAAC;AAYlD,SAAS,2BAAoD;AAClE,MAAI;AAGJ,iBAAe,+BAAmE;AAChF,wBAAoB,8BAA8B,EAAE,MAAM,CAAC,UAAmB;AAC5E,wBAAkB;AAClB,YAAM;AAAA,IACR,CAAC;AACD,WAAO,MAAM;AAAA,EACf;AAEA,iBAAe,uBAAuB,MAAiB,UAAkB,QAAiF;AACxJ,QAAI;AACJ,QAAI;AACF,iBAAW,MAAM,6BAA6B;AAAA,IAChD,SAAS,OAAO;AACd,UAAI,CAAC,+BAA+B,KAAK,GAAG;AAC1C,cAAM;AAAA,MACR;AACA,YAAM,IAAI;AAAA,QACR,0BAA0B,IAAI,UAAU,QAAQ,eAAe,OAAO,YAAY,oBAAoB,6DAA6D,QAAQ;AAAA,QAC3K,EAAE,OAAO,MAAM;AAAA,MACjB;AAAA,IACF;AACA,WAAO,MAAM,SAAS,IAAI,IAAI,MAAM,KAA6C;AAAA,EACnF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,OAAO,QAAuD;AAClE,YAAM,WAAW,iBAAiB,OAAO,UAAU;AACnD,UAAI,aAAa,UAAa,qBAAqB,IAAI,QAAQ,GAAG;AAChE,eAAO;AAAA,MACT;AACA,aAAO,qBAAqB,IAAI,QAAQ,IAAK,MAAM,oBAAoB,MAAM,IAAM,MAAM,uBAAuB,UAAU,UAAU,MAAM;AAAA,IAC5I;AAAA,IACA,MAAM,MAAM,QAAuD;AACjE,YAAM,WAAW,iBAAiB,OAAO,UAAU;AACnD,aAAO,aAAa,UAAa,aAAa,QAAQ,SAAa,MAAM,uBAAuB,SAAS,UAAU,MAAM;AAAA,IAC3H;AAAA,EACF;AACF;AAQO,SAAS,iBAAiB,YAAuD;AACtF,QAAM,OAAO,WAAW,MAAM;AAC9B,MAAI,OAAO,SAAS,YAAY,SAAS,IAAI;AAC3C,WAAO,KAAK,YAAY;AAAA,EAC1B;AAEA,QAAM,OAAO,WAAW,MAAM;AAC9B,SAAO,OAAO,SAAS,YAAY,KAAK,YAAY,EAAE,WAAW,gBAAgB,IAAI,KAAK,MAAM,iBAAiB,MAAM,EAAE,YAAY,IAAI;AAC3I;AAQO,SAAS,+BAA+B,OAAyB;AACtE,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO;AAAA,EACT;AAEA,QAAM,OAAQ,MAA2C;AACzD,SAAO,OAAO,SAAS,YAAY,uBAAuB,IAAI,IAAI,KAAK,0CAA0C,KAAK,MAAM,OAAO;AACrI;AAEA,eAAe,gCAAoE;AAKjF,QAAM,uBAAuB,MAAM,OAAO;AAC1C,SAAO,qBAAqB,iBAAiB;AAC/C;AAEA,eAAe,oBAAoB,QAAqE;AACtG,QAAM,SAAS,MAAM,UAAU,OAAO,SAAS;AAAA,IAC7C,QAAQ;AAAA,IACR,YAAY,OAAO,YAAY;AAAA,IAC/B,WAAW;AAAA,IACX,QAAQ;AAAA,IACR,aAAa;AAAA,MACX,iBAAiB;AAAA,QACf,sBAAsB;AAAA,MACxB;AAAA,IACF;AAAA,EACF,CAAC;AACD,SAAO;AAAA,IACL,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,EACd;AACF;","names":[]}

package/dist/lib/esm/bundlers/esbuild-impl/svelte-wrapper-plugin.d.mts

@@ -18,7 +18,7 @@ export declare function isMissingSveltePackageError(error: unknown): boolean;
 /**
  * Wraps the esbuild-svelte plugin to ensure that the correct format is used.
  *
- * `esbuild-svelte` and `svelte-preprocess` are loaded when the plugin is set up, not when this module is imported. When
+ * `esbuild-svelte` is loaded when the plugin is set up, not when this module is imported. When
  * the `svelte` package is not installed, a build with no `.svelte` file succeeds, and a build that reaches one fails
  * with an error that names the missing package.
  *

package/dist/lib/esm/bundlers/esbuild-impl/svelte-wrapper-plugin.mjs

@@ -38,6 +38,7 @@ ensureBrowserProcess();
 
 import { extractDefaultExportInterop } from "@mnaoumov/typescript-lib/object-utils";
 import { readPackageJson } from "../../npm.mjs";
+import { createSveltePreprocessor } from "./svelte-preprocessor.mjs";
 const MISSING_SVELTE_MESSAGE_REG_EXP = /Cannot find (?:module|package) 'svelte(?:\/[^']*)?'/;
 const MODULE_NOT_FOUND_CODES = /* @__PURE__ */ new Set(["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"]);
 const SVELTE_FILTER = /\.svelte$/;
@@ -75,7 +76,7 @@ function svelteWrapperPlugin(isProductionBuild) {
   };
 }
 async function createEsbuildSveltePlugin(isProductionBuild) {
-  const [esbuildSvelteModule, { sveltePreprocess }] = await Promise.all([import("esbuild-svelte"), import("svelte-preprocess")]);
+  const esbuildSvelteModule = await import("esbuild-svelte");
   const esbuildSvelte = extractDefaultExportInterop(esbuildSvelteModule.default);
   return esbuildSvelte({
     compilerOptions: {
@@ -85,7 +86,7 @@ async function createEsbuildSveltePlugin(isProductionBuild) {
     moduleCompilerOptions: {
       dev: !isProductionBuild
     },
-    preprocess: sveltePreprocess()
+    preprocess: createSveltePreprocessor()
   });
 }
 function registerMissingSvelteLoader(build) {
@@ -99,4 +100,4 @@ export {
   isMissingSveltePackageError,
   svelteWrapperPlugin
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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