@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.1.0

package/dist/lib/esm/bundlers/obsidian-plugin-features.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 { getRootFolder } from "@mnaoumov/typescript-dev-toolkit/root";
+import { join } from "@mnaoumov/typescript-lib/path";
+import { escapeRegExp } from "@mnaoumov/typescript-lib/reg-exp";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+const CSS_MODULE_FILE_PATTERN = /\.module\.(?:css|pcss|s[ac]ss)$/iu;
+const JSX_SOURCE_FILE_PATTERN = /\.[jt]sx$/iu;
+const STYLESHEET_FILE_PATTERN = /\.p?css$/iu;
+const SVELTE_FILE_PATTERN = /\.svelte(?:\.[cm]?[jt]s)?$/iu;
+const WASM_FILE_PATTERN = /\.wasm$/iu;
+const VIRTUAL_MODULE_PREFIX = "\0";
+function getFeatureFileKind(id) {
+  if (id.startsWith(VIRTUAL_MODULE_PREFIX)) {
+    return void 0;
+  }
+  if (STYLESHEET_FILE_PATTERN.test(id)) {
+    return "stylesheet";
+  }
+  const [filePath = ""] = id.split("?", 1);
+  if (SVELTE_FILE_PATTERN.test(filePath)) {
+    return "svelte";
+  }
+  if (JSX_SOURCE_FILE_PATTERN.test(filePath)) {
+    return "jsx";
+  }
+  return WASM_FILE_PATTERN.test(filePath) ? "wasm" : void 0;
+}
+function getFrameworkDefines(params) {
+  const { framework, isProductionBuild } = params;
+  if (framework === void 0) {
+    return {};
+  }
+  const defines = {
+    "process.env.NODE_ENV": JSON.stringify(isProductionBuild ? "production" : "development")
+  };
+  if (framework === "vue") {
+    defines["__VUE_OPTIONS_API__"] = "true";
+    defines["__VUE_PROD_DEVTOOLS__"] = "false";
+    defines["__VUE_PROD_HYDRATION_MISMATCH_DETAILS__"] = "false";
+  }
+  return defines;
+}
+function getJsxImportSource(framework) {
+  return framework === "preact" || framework === "react" ? framework : void 0;
+}
+async function importOptionalPeer(params) {
+  return await import(pathToFileURL(resolveOptionalPeer(params)).href);
+}
+function isCssModuleFile(filePath) {
+  return CSS_MODULE_FILE_PATTERN.test(filePath);
+}
+function isPostcssNeeded(styles) {
+  return Boolean(styles?.postcss) || Boolean(styles?.tailwind);
+}
+function replaceDefines(code, defines) {
+  let result = code;
+  for (const [expression, value] of Object.entries(defines)) {
+    if (!result.includes(expression)) {
+      continue;
+    }
+    result = result.replace(new RegExp(String.raw`(?<![\w$.])${escapeRegExp(expression)}(?![\w$])`, "gu"), () => value);
+  }
+  return result;
+}
+function requireOptionalPeer(params) {
+  return createProjectRequire(params.projectFolder)(resolveOptionalPeer(params));
+}
+function resolveOptionalPeer(params) {
+  const { feature, packageName } = params;
+  try {
+    return createProjectRequire(params.projectFolder).resolve(params.specifier ?? packageName);
+  } catch (error) {
+    throw new Error(
+      `The \`${feature}\` build option needs \`${packageName}\`, which this project does not have. Install it with: npm install --save-dev ${packageName}`,
+      { cause: error }
+    );
+  }
+}
+function createProjectRequire(projectFolder) {
+  return createRequire(join(projectFolder ?? getRootFolder() ?? process.cwd(), "package.json"));
+}
+export {
+  getFeatureFileKind,
+  getFrameworkDefines,
+  getJsxImportSource,
+  importOptionalPeer,
+  isCssModuleFile,
+  isPostcssNeeded,
+  replaceDefines,
+  requireOptionalPeer,
+  resolveOptionalPeer
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/obsidian-plugin-features.ts"],"sourcesContent":["/**\n * @file\n *\n * The build features every bundler adapter offers beside the plain plugin build: a UI framework, the stylesheet\n * pipeline and WebAssembly. Every adapter takes the same {@link ObsidianPluginFeatureOptions}, so a project that\n * switches bundler keeps its options and its installed packages.\n *\n * Each feature's packages are optional peer dependencies of the toolkit, imported from the PROJECT's own\n * `node_modules` only when the feature is on, through {@link importOptionalPeer}.\n *\n * Erasable TypeScript only (no enums, no parameter properties): `obsidian-plugin-transforms.ts` imports this module,\n * and a webpack loader or a parcel worker loads that one straight from source when the toolkit runs from source.\n */\n\nimport { getRootFolder } from '@mnaoumov/typescript-dev-toolkit/root';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { escapeRegExp } from '@mnaoumov/typescript-lib/reg-exp';\nimport { createRequire } from 'node:module';\nimport process from 'node:process';\nimport { pathToFileURL } from 'node:url';\n\n/**\n * Which shared transform a module goes through, as {@link getFeatureFileKind} tells it.\n */\nexport type FeatureFileKind = 'jsx' | 'stylesheet' | 'svelte' | 'wasm';\n\n/**\n * Parameters for {@link getFrameworkDefines}.\n */\nexport interface GetFrameworkDefinesParams {\n  /**\n   * The UI framework, if any.\n   */\n  readonly framework: ObsidianPluginFramework | undefined;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n}\n\n/**\n * Parameters for {@link importOptionalPeer}.\n */\nexport interface ImportOptionalPeerParams {\n  /**\n   * The option that needs the package, as the error message names it, e.g. `framework: 'solid'`.\n   */\n  readonly feature: string;\n\n  /**\n   * The package to install when it is missing.\n   */\n  readonly packageName: string;\n\n  /**\n   * The folder whose `node_modules` the package is resolved from. Defaults to the project root.\n   */\n  readonly projectFolder?: string;\n\n  /**\n   * The module to import. Defaults to {@link packageName}.\n   */\n  readonly specifier?: string;\n}\n\n/**\n * The build features beside the plain plugin build. Every option is off unless set.\n */\nexport interface ObsidianPluginFeatureOptions {\n  /**\n   * The UI framework whose components the build compiles.\n   */\n  readonly framework?: ObsidianPluginFramework;\n\n  /**\n   * The stylesheet pipeline.\n   */\n  readonly styles?: ObsidianPluginStylesOptions;\n\n  /**\n   * Whether `import bytes from './module.wasm'` imports the module's bytes as a `Uint8Array`, inlined into `main.js`.\n   */\n  readonly wasm?: boolean;\n}\n\n/**\n * A UI framework the bundler adapters compile.\n *\n * - `react` and `preact` compile JSX with the automatic runtime from `react` / `preact`.\n * - `solid` compiles JSX with `babel-preset-solid`.\n * - `svelte` compiles `.svelte` components and `.svelte.ts` / `.svelte.js` modules with the project's `svelte`.\n * - `vue` compiles single-file components with `unplugin-vue` (on parcel, with `@parcel/transformer-vue`).\n */\nexport type ObsidianPluginFramework = 'preact' | 'react' | 'solid' | 'svelte' | 'vue';\n\n/**\n * The stylesheet pipeline of {@link ObsidianPluginFeatureOptions}.\n */\nexport interface ObsidianPluginStylesOptions {\n  /**\n   * Whether a `*.module.css` file is a CSS module: its class names are scoped, and importing it gives the scoped\n   * names by their original ones.\n   */\n  readonly cssModules?: boolean;\n\n  /**\n   * Whether every stylesheet goes through the project's PostCSS configuration (`postcss.config.*`, `.postcssrc*`, or\n   * `postcss` in `package.json`).\n   */\n  readonly postcss?: boolean;\n\n  /**\n   * Whether every stylesheet goes through Tailwind CSS 4 (`@tailwindcss/postcss`), so `@import \"tailwindcss\";`\n   * expands to the utilities the sources use.\n   */\n  readonly tailwind?: boolean;\n}\n\n/**\n * Parameters for {@link requireOptionalPeer}: the same as {@link ImportOptionalPeerParams}.\n */\nexport type RequireOptionalPeerParams = ImportOptionalPeerParams;\n\n/**\n * Parameters for {@link resolveOptionalPeer}: the same as {@link ImportOptionalPeerParams}.\n */\nexport type ResolveOptionalPeerParams = ImportOptionalPeerParams;\n\nconst CSS_MODULE_FILE_PATTERN = /\\.module\\.(?:css|pcss|s[ac]ss)$/iu;\nconst JSX_SOURCE_FILE_PATTERN = /\\.[jt]sx$/iu;\nconst STYLESHEET_FILE_PATTERN = /\\.p?css$/iu;\nconst SVELTE_FILE_PATTERN = /\\.svelte(?:\\.[cm]?[jt]s)?$/iu;\nconst WASM_FILE_PATTERN = /\\.wasm$/iu;\nconst VIRTUAL_MODULE_PREFIX = '\\0';\n\n/**\n * Tells which shared transform a module of a rollup-family build goes through, by its id.\n *\n * A virtual module (an id starting with `\\0`) goes through none. A query is part of the match for a stylesheet, so a\n * Vue component's `?vue&type=style&lang.css` block counts as one, and is cut off for the rest.\n *\n * @param id - The module id.\n * @returns The kind of file, or `undefined` for a module no feature transforms.\n */\nexport function getFeatureFileKind(id: string): FeatureFileKind | undefined {\n  if (id.startsWith(VIRTUAL_MODULE_PREFIX)) {\n    return undefined;\n  }\n  if (STYLESHEET_FILE_PATTERN.test(id)) {\n    return 'stylesheet';\n  }\n  const [filePath = ''] = id.split('?', 1);\n  if (SVELTE_FILE_PATTERN.test(filePath)) {\n    return 'svelte';\n  }\n  if (JSX_SOURCE_FILE_PATTERN.test(filePath)) {\n    return 'jsx';\n  }\n  return WASM_FILE_PATTERN.test(filePath) ? 'wasm' : undefined;\n}\n\n/**\n * Builds the compile-time constants a framework's runtime reads, which Obsidian's renderer does not define.\n *\n * `process.env.NODE_ENV` picks a runtime's production build (React, Preact's devtools, Vue, Solid), and without it a\n * production plugin would bundle and run the development one. Vue also reads its three feature flags.\n *\n * @param params - The {@link GetFrameworkDefinesParams}.\n * @returns The constants, by expression, each value a JavaScript literal. Empty when there is no framework.\n */\nexport function getFrameworkDefines(params: GetFrameworkDefinesParams): Record<string, string> {\n  const { framework, isProductionBuild } = params;\n  if (framework === undefined) {\n    return {};\n  }\n\n  const defines: Record<string, string> = {\n    'process.env.NODE_ENV': JSON.stringify(isProductionBuild ? 'production' : 'development')\n  };\n  if (framework === 'vue') {\n    defines['__VUE_OPTIONS_API__'] = 'true';\n    defines['__VUE_PROD_DEVTOOLS__'] = 'false';\n    defines['__VUE_PROD_HYDRATION_MISMATCH_DETAILS__'] = 'false';\n  }\n  return defines;\n}\n\n/**\n * Tells which package supplies the automatic JSX runtime of a framework.\n *\n * @param framework - The UI framework, if any.\n * @returns `react` or `preact`, or `undefined` for a framework that does not compile JSX with the automatic runtime.\n */\nexport function getJsxImportSource(framework: ObsidianPluginFramework | undefined): 'preact' | 'react' | undefined {\n  return framework === 'preact' || framework === 'react' ? framework : undefined;\n}\n\n/**\n * Imports an optional peer dependency from the project's own `node_modules`.\n *\n * Resolved from the project rather than from the toolkit, so a package manager that does not hoist still finds what\n * the project installed.\n *\n * @typeParam Module - The module's type.\n * @param params - The {@link ImportOptionalPeerParams}.\n * @returns A {@link Promise} that resolves to the module namespace.\n * @throws If the project does not have the package, naming the option that needs it and the command that installs it.\n */\nexport async function importOptionalPeer<Module>(params: ImportOptionalPeerParams): Promise<Module> {\n  // eslint-disable-next-line no-unsanitized/method -- The path is what Node resolved the package name to, from the project's own `node_modules`.\n  return await import(pathToFileURL(resolveOptionalPeer(params)).href) as Module;\n}\n\n/**\n * Tells whether a stylesheet is a CSS module by its file name.\n *\n * @param filePath - The stylesheet's path.\n * @returns `true` for `*.module.css` (and `.module.pcss`, `.module.scss`, `.module.sass`).\n */\nexport function isCssModuleFile(filePath: string): boolean {\n  return CSS_MODULE_FILE_PATTERN.test(filePath);\n}\n\n/**\n * Tells whether a stylesheet goes through PostCSS at all.\n *\n * @param styles - The stylesheet options, if any.\n * @returns `true` when the project's PostCSS configuration or Tailwind applies.\n */\nexport function isPostcssNeeded(styles: ObsidianPluginStylesOptions | undefined): boolean {\n  return Boolean(styles?.postcss) || Boolean(styles?.tailwind);\n}\n\n/**\n * Replaces each compile-time constant in a module's code with its value, as a bundler's `define` does: only where\n * the whole expression stands on its own, so `process.env.NODE_ENV` is replaced and `a.process.env.NODE_ENV` or\n * `process.env.NODE_ENV_X` are not.\n *\n * @param code - The module's code.\n * @param defines - The constants, by expression, each value a JavaScript literal.\n * @returns The code with the constants replaced.\n */\nexport function replaceDefines(code: string, defines: Readonly<Record<string, string>>): string {\n  let result = code;\n  for (const [expression, value] of Object.entries(defines)) {\n    if (!result.includes(expression)) {\n      continue;\n    }\n    result = result.replace(new RegExp(String.raw`(?<![\\w$.])${escapeRegExp(expression)}(?![\\w$])`, 'gu'), () => value);\n  }\n  return result;\n}\n\n/**\n * Loads an optional peer dependency from the project's own `node_modules` synchronously, for a bundler whose plugins\n * are applied synchronously (webpack). Loads an ES module too, through `require`.\n *\n * @param params - The {@link RequireOptionalPeerParams}.\n * @returns The module, for the caller to type.\n * @throws If the project does not have the package, naming the option that needs it and the command that installs it.\n */\nexport function requireOptionalPeer(params: RequireOptionalPeerParams): unknown {\n  return createProjectRequire(params.projectFolder)(resolveOptionalPeer(params));\n}\n\n/**\n * Resolves an optional peer dependency from the project's own `node_modules`.\n *\n * @param params - The {@link ResolveOptionalPeerParams}.\n * @returns The absolute path of the module.\n * @throws If the project does not have the package, naming the option that needs it and the command that installs it.\n */\nexport function resolveOptionalPeer(params: ResolveOptionalPeerParams): string {\n  const { feature, packageName } = params;\n  try {\n    return createProjectRequire(params.projectFolder).resolve(params.specifier ?? packageName);\n  } catch (error) {\n    throw new Error(\n      `The \\`${feature}\\` build option needs \\`${packageName}\\`, which this project does not have. Install it with: npm install --save-dev ${packageName}`,\n      { cause: error }\n    );\n  }\n}\n\nfunction createProjectRequire(projectFolder: string | undefined): NodeJS.Require {\n  return createRequire(join(projectFolder ?? getRootFolder() ?? process.cwd(), 'package.json'));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcA,SAAS,qBAAqB;AAC9B,SAAS,YAAY;AACrB,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAC9B,OAAO,aAAa;AACpB,SAAS,qBAAqB;AA8G9B,MAAM,0BAA0B;AAChC,MAAM,0BAA0B;AAChC,MAAM,0BAA0B;AAChC,MAAM,sBAAsB;AAC5B,MAAM,oBAAoB;AAC1B,MAAM,wBAAwB;AAWvB,SAAS,mBAAmB,IAAyC;AAC1E,MAAI,GAAG,WAAW,qBAAqB,GAAG;AACxC,WAAO;AAAA,EACT;AACA,MAAI,wBAAwB,KAAK,EAAE,GAAG;AACpC,WAAO;AAAA,EACT;AACA,QAAM,CAAC,WAAW,EAAE,IAAI,GAAG,MAAM,KAAK,CAAC;AACvC,MAAI,oBAAoB,KAAK,QAAQ,GAAG;AACtC,WAAO;AAAA,EACT;AACA,MAAI,wBAAwB,KAAK,QAAQ,GAAG;AAC1C,WAAO;AAAA,EACT;AACA,SAAO,kBAAkB,KAAK,QAAQ,IAAI,SAAS;AACrD;AAWO,SAAS,oBAAoB,QAA2D;AAC7F,QAAM,EAAE,WAAW,kBAAkB,IAAI;AACzC,MAAI,cAAc,QAAW;AAC3B,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,UAAkC;AAAA,IACtC,wBAAwB,KAAK,UAAU,oBAAoB,eAAe,aAAa;AAAA,EACzF;AACA,MAAI,cAAc,OAAO;AACvB,YAAQ,qBAAqB,IAAI;AACjC,YAAQ,uBAAuB,IAAI;AACnC,YAAQ,yCAAyC,IAAI;AAAA,EACvD;AACA,SAAO;AACT;AAQO,SAAS,mBAAmB,WAAgF;AACjH,SAAO,cAAc,YAAY,cAAc,UAAU,YAAY;AACvE;AAaA,eAAsB,mBAA2B,QAAmD;AAElG,SAAO,MAAM,OAAO,cAAc,oBAAoB,MAAM,CAAC,EAAE;AACjE;AAQO,SAAS,gBAAgB,UAA2B;AACzD,SAAO,wBAAwB,KAAK,QAAQ;AAC9C;AAQO,SAAS,gBAAgB,QAA0D;AACxF,SAAO,QAAQ,QAAQ,OAAO,KAAK,QAAQ,QAAQ,QAAQ;AAC7D;AAWO,SAAS,eAAe,MAAc,SAAmD;AAC9F,MAAI,SAAS;AACb,aAAW,CAAC,YAAY,KAAK,KAAK,OAAO,QAAQ,OAAO,GAAG;AACzD,QAAI,CAAC,OAAO,SAAS,UAAU,GAAG;AAChC;AAAA,IACF;AACA,aAAS,OAAO,QAAQ,IAAI,OAAO,OAAO,iBAAiB,aAAa,UAAU,CAAC,aAAa,IAAI,GAAG,MAAM,KAAK;AAAA,EACpH;AACA,SAAO;AACT;AAUO,SAAS,oBAAoB,QAA4C;AAC9E,SAAO,qBAAqB,OAAO,aAAa,EAAE,oBAAoB,MAAM,CAAC;AAC/E;AASO,SAAS,oBAAoB,QAA2C;AAC7E,QAAM,EAAE,SAAS,YAAY,IAAI;AACjC,MAAI;AACF,WAAO,qBAAqB,OAAO,aAAa,EAAE,QAAQ,OAAO,aAAa,WAAW;AAAA,EAC3F,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,SAAS,OAAO,2BAA2B,WAAW,iFAAiF,WAAW;AAAA,MAClJ,EAAE,OAAO,MAAM;AAAA,IACjB;AAAA,EACF;AACF;AAEA,SAAS,qBAAqB,eAAmD;AAC/E,SAAO,cAAc,KAAK,iBAAiB,cAAc,KAAK,QAAQ,IAAI,GAAG,cAAc,CAAC;AAC9F;","names":[]}

package/dist/lib/esm/bundlers/obsidian-plugin-transforms.d.mts

@@ -0,0 +1,231 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The source transforms every bundler adapter shares, so a feature compiles the same way whichever bundler runs it:
+ * Solid's JSX, Svelte components and modules, stylesheets through PostCSS, Tailwind and CSS modules, and WebAssembly
+ * modules as bytes. The esbuild, rollup and vite adapters call them in-process; the webpack adapter through the
+ * loader it ships, and the parcel adapter through the transformers it generates.
+ *
+ * Erasable TypeScript only (no enums, no parameter properties), so a webpack loader or a parcel worker can load this
+ * module straight from source when the toolkit runs from source.
+ */
+import type { AcceptedPlugin, ProcessOptions } from 'postcss';
+import type { ObsidianPluginStylesOptions } from './obsidian-plugin-features.mjs';
+/**
+ * Parameters for {@link loadPostcssConfig}.
+ */
+export interface LoadPostcssConfigParams {
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.
+     */
+    readonly projectFolder?: string | undefined;
+    /**
+     * The stylesheet options.
+     */
+    readonly styles: ObsidianPluginStylesOptions;
+}
+/**
+ * What {@link loadPostcssConfig} loaded.
+ */
+export interface PostcssConfig {
+    /**
+     * The files the configuration came from, for a watch build to watch.
+     */
+    readonly dependencies: readonly string[];
+    /**
+     * The process options of the project's configuration (a custom parser or syntax, say).
+     */
+    readonly options: ProcessOptions;
+    /**
+     * The plugins, in the order they run.
+     */
+    readonly plugins: readonly AcceptedPlugin[];
+}
+/**
+ * A source map, as the transforms hand it over: the decoded JSON of a version 3 source map.
+ */
+export interface SourceMapLike {
+    /**
+     * The encoded mappings.
+     */
+    readonly mappings: string;
+    /**
+     * The original sources.
+     */
+    readonly sources: readonly string[];
+    /**
+     * The source map version.
+     */
+    readonly version: number;
+}
+/**
+ * Parameters for {@link transformCss}.
+ */
+export interface TransformCssParams {
+    /**
+     * The stylesheet's path.
+     */
+    readonly filePath: string;
+    /**
+     * Whether `*.module.css` files are scoped here. A bundler that scopes CSS modules itself passes `false`.
+     */
+    readonly isCssModuleScoped: boolean;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.
+     */
+    readonly projectFolder?: string | undefined;
+    /**
+     * The stylesheet's contents.
+     */
+    readonly source: string;
+    /**
+     * The stylesheet options.
+     */
+    readonly styles: ObsidianPluginStylesOptions;
+}
+/**
+ * The CSS {@link transformCss} produced.
+ */
+export interface TransformedCss {
+    /**
+     * The stylesheet.
+     */
+    readonly css: string;
+    /**
+     * The files besides the stylesheet that the result depends on, for a watch build to watch: a PostCSS configuration,
+     * or a stylesheet a plugin inlined.
+     */
+    readonly dependencies: readonly string[];
+    /**
+     * The scoped class names by their original ones, for a CSS module; `undefined` for an ordinary stylesheet.
+     */
+    readonly moduleExports: Readonly<Record<string, string>> | undefined;
+}
+/**
+ * A JavaScript module a transform produced.
+ */
+export interface TransformedModule {
+    /**
+     * The JavaScript code.
+     */
+    readonly code: string;
+    /**
+     * Its source map, or `undefined` when there is none.
+     */
+    readonly map: SourceMapLike | undefined;
+}
+/**
+ * Parameters for {@link transformJsx}.
+ */
+export interface TransformJsxParams extends TransformModuleParams {
+    /**
+     * The package that supplies the automatic JSX runtime: `react` or `preact`.
+     */
+    readonly jsxImportSource: string;
+}
+/**
+ * Parameters of a transform that compiles one module.
+ */
+export interface TransformModuleParams {
+    /**
+     * The source code.
+     */
+    readonly code: string;
+    /**
+     * The source file's path.
+     */
+    readonly filePath: string;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder the framework's packages are resolved from. Defaults to the project root.
+     */
+    readonly projectFolder?: string;
+}
+/**
+ * Parameters for {@link transformSolid}.
+ */
+export type TransformSolidParams = TransformModuleParams;
+/**
+ * Parameters for {@link transformSvelte}.
+ */
+export type TransformSvelteParams = TransformModuleParams;
+/**
+ * Appends a source map to a module's code as an inline `sourceMappingURL` comment, which is how a bundler that
+ * reads a loaded file's own source map takes it.
+ *
+ * @param module - The module.
+ * @returns The code, with the source map inlined when there is one.
+ */
+export declare function appendInlineSourceMap(module: TransformedModule): string;
+/**
+ * Builds the JavaScript module a CSS module's import resolves to: its scoped class names, by their original ones, as
+ * the default export.
+ *
+ * @param moduleExports - The scoped class names.
+ * @returns The module's code.
+ */
+export declare function getCssModuleCode(moduleExports: Readonly<Record<string, string>>): string;
+/**
+ * Builds the JavaScript module a `.wasm` import resolves to: the WebAssembly module's bytes as a `Uint8Array`
+ * default export, inlined as base64, because an Obsidian release ships `main.js` and nothing beside it.
+ *
+ * @param bytes - The WebAssembly module's bytes.
+ * @returns The module's code.
+ */
+export declare function getWasmModuleCode(bytes: Uint8Array): string;
+/**
+ * Loads the PostCSS plugins a stylesheet goes through, without the CSS-module scoping: the project's PostCSS
+ * configuration when `postcss` is on, and Tailwind ahead of it when `tailwind` is on and the configuration does not
+ * already run it.
+ *
+ * @param params - The {@link LoadPostcssConfigParams}.
+ * @returns A {@link Promise} that resolves to the {@link PostcssConfig}; its `plugins` is empty when neither applies.
+ * @throws If `postcss` is on and the project has no PostCSS configuration.
+ */
+export declare function loadPostcssConfig(params: LoadPostcssConfigParams): Promise<PostcssConfig>;
+/**
+ * Runs a stylesheet through the pipeline its options ask for: the project's PostCSS configuration, Tailwind, and the
+ * CSS-module scoping of a `*.module.css` file.
+ *
+ * @param params - The {@link TransformCssParams}.
+ * @returns A {@link Promise} that resolves to the {@link TransformedCss}.
+ * @throws If `postcss` is on and the project has no PostCSS configuration.
+ */
+export declare function transformCss(params: TransformCssParams): Promise<TransformedCss>;
+/**
+ * Compiles a React or Preact JSX or TSX module with the automatic JSX runtime, for a bundler that does not take the
+ * runtime from the project's tsconfig (parcel does not follow its `extends`).
+ *
+ * @param params - The {@link TransformJsxParams}.
+ * @returns A {@link Promise} that resolves to the compiled module.
+ */
+export declare function transformJsx(params: TransformJsxParams): Promise<TransformedModule>;
+/**
+ * Compiles a Solid JSX or TSX module: esbuild strips the TypeScript and keeps the JSX, then `babel-preset-solid`
+ * compiles the JSX into DOM expressions.
+ *
+ * @param params - The {@link TransformModuleParams}.
+ * @returns A {@link Promise} that resolves to the compiled module.
+ * @throws If Babel produced no code.
+ */
+export declare function transformSolid(params: TransformSolidParams): Promise<TransformedModule>;
+/**
+ * Compiles a Svelte component (`.svelte`), with its styles injected by the component itself, or a Svelte module
+ * (`.svelte.ts`, `.svelte.js`), whose TypeScript esbuild strips first.
+ *
+ * @param params - The {@link TransformModuleParams}.
+ * @returns A {@link Promise} that resolves to the compiled module.
+ */
+export declare function transformSvelte(params: TransformSvelteParams): Promise<TransformedModule>;

package/dist/lib/esm/bundlers/obsidian-plugin-transforms.mjs

@@ -0,0 +1,194 @@
+/*
+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 { extractDefaultExportInterop } from "@mnaoumov/typescript-lib/object-utils";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { transform as esbuildTransform } from "esbuild";
+import process from "node:process";
+import postcss from "postcss";
+import postcssLoadConfig_ from "postcss-load-config";
+import postcssModules_ from "postcss-modules";
+import {
+  importOptionalPeer,
+  isCssModuleFile
+} from "./obsidian-plugin-features.mjs";
+const postcssLoadConfig = extractDefaultExportInterop(postcssLoadConfig_);
+const postcssModules = extractDefaultExportInterop(postcssModules_);
+const SVELTE_MODULE_PATTERN = /\.svelte\.[cm]?[jt]s$/iu;
+const TYPESCRIPT_MODULE_PATTERN = /\.[cm]?ts$/iu;
+const TAILWIND_POSTCSS_PLUGIN_NAME = "@tailwindcss/postcss";
+function appendInlineSourceMap(module) {
+  if (!module.map) {
+    return module.code;
+  }
+  const base64 = Buffer.from(JSON.stringify(module.map), "utf-8").toString("base64");
+  return `${module.code}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64}
+`;
+}
+function getCssModuleCode(moduleExports) {
+  return `export default ${JSON.stringify(moduleExports)};
+`;
+}
+function getWasmModuleCode(bytes) {
+  const base64 = Buffer.from(bytes).toString("base64");
+  return `const binary = atob(${JSON.stringify(base64)});
+const bytes = new Uint8Array(binary.length);
+for (let i = 0; i < binary.length; i++) {
+  bytes[i] = binary.charCodeAt(i);
+}
+export default bytes;
+`;
+}
+async function loadPostcssConfig(params) {
+  const { isProductionBuild, projectFolder, styles } = params;
+  const plugins = [];
+  const dependencies = [];
+  let options = {};
+  if (styles.postcss) {
+    let config;
+    try {
+      config = await postcssLoadConfig({ cwd: projectFolder ?? process.cwd(), env: isProductionBuild ? "production" : "development" }, projectFolder);
+    } catch (error) {
+      throw new Error("The `styles.postcss` build option needs a PostCSS configuration (`postcss.config.mjs`, `.postcssrc.json`, ...) in the project.", {
+        cause: error
+      });
+    }
+    plugins.push(...config.plugins);
+    options = config.options;
+    dependencies.push(config.file);
+  }
+  if (styles.tailwind && plugins.every((plugin) => !isTailwindPlugin(plugin))) {
+    const { default: tailwind } = await importOptionalPeer({
+      feature: "styles.tailwind",
+      packageName: TAILWIND_POSTCSS_PLUGIN_NAME,
+      ...projectFolder !== void 0 && { projectFolder }
+    });
+    plugins.unshift(tailwind({ ...projectFolder !== void 0 && { base: projectFolder }, optimize: isProductionBuild }));
+  }
+  return { dependencies, options, plugins };
+}
+async function transformCss(params) {
+  const { filePath, isCssModuleScoped, source, styles } = params;
+  const postcssConfig = await loadPostcssConfig(params);
+  const plugins = [...postcssConfig.plugins];
+  const dependencies = [...postcssConfig.dependencies];
+  let moduleExports;
+  if (styles.cssModules && isCssModuleScoped && isCssModuleFile(filePath)) {
+    plugins.push(postcssModules({
+      getJSON(_cssFileName, json) {
+        moduleExports = json;
+      }
+    }));
+  }
+  if (plugins.length === 0) {
+    return { css: source, dependencies, moduleExports };
+  }
+  const result = await postcss(plugins).process(source, { ...postcssConfig.options, from: filePath, map: false });
+  for (const message of result.messages) {
+    if (message.type === "dependency" && message.file !== void 0) {
+      dependencies.push(message.file);
+    }
+  }
+  return { css: result.css, dependencies, moduleExports };
+}
+async function transformJsx(params) {
+  const { code, filePath, jsxImportSource } = params;
+  const result = await esbuildTransform(code, {
+    jsx: "automatic",
+    jsxImportSource,
+    loader: /\.tsx$/iu.test(filePath) ? "tsx" : "jsx",
+    sourcefile: filePath,
+    sourcemap: "external"
+  });
+  return { code: result.code, map: JSON.parse(result.map) };
+}
+async function transformSolid(params) {
+  const { code, filePath } = params;
+  const feature = "framework: 'solid'";
+  const projectFolderOption = params.projectFolder === void 0 ? {} : { projectFolder: params.projectFolder };
+  const babel = extractDefaultExportInterop(await importOptionalPeer({ feature, packageName: "@babel/core", ...projectFolderOption }));
+  const solidPreset = extractDefaultExportInterop(await importOptionalPeer({ feature, packageName: "babel-preset-solid", ...projectFolderOption }));
+  const stripped = await esbuildTransform(code, {
+    jsx: "preserve",
+    loader: /\.tsx$/iu.test(filePath) ? "tsx" : "jsx",
+    sourcefile: filePath,
+    sourcemap: "external"
+  });
+  const result = await babel.transformAsync(stripped.code, {
+    babelrc: false,
+    configFile: false,
+    filename: filePath,
+    inputSourceMap: JSON.parse(stripped.map),
+    presets: [[solidPreset, { generate: "dom", hydratable: false }]],
+    sourceMaps: true
+  });
+  if (!result?.code) {
+    throw new Error(`Babel produced no code for ${filePath}`);
+  }
+  return { code: result.code, map: ensureNonNullable(result.map, `Babel produced no source map for ${filePath}`) };
+}
+async function transformSvelte(params) {
+  const { code, filePath, isProductionBuild } = params;
+  const compiler = extractDefaultExportInterop(
+    await importOptionalPeer({
+      feature: "framework: 'svelte'",
+      packageName: "svelte",
+      specifier: "svelte/compiler",
+      ...params.projectFolder !== void 0 && { projectFolder: params.projectFolder }
+    })
+  );
+  const moduleOptions = { dev: !isProductionBuild, filename: filePath, generate: "client" };
+  if (SVELTE_MODULE_PATTERN.test(filePath)) {
+    let javaScript = code;
+    if (TYPESCRIPT_MODULE_PATTERN.test(filePath)) {
+      const stripped = await esbuildTransform(code, { loader: "ts", sourcefile: filePath });
+      javaScript = stripped.code;
+    }
+    return compiler.compileModule(javaScript, moduleOptions).js;
+  }
+  return compiler.compile(code, { ...moduleOptions, css: "injected" }).js;
+}
+function isTailwindPlugin(plugin) {
+  return typeof plugin === "object" && "postcssPlugin" in plugin && plugin.postcssPlugin === TAILWIND_POSTCSS_PLUGIN_NAME;
+}
+export {
+  appendInlineSourceMap,
+  getCssModuleCode,
+  getWasmModuleCode,
+  loadPostcssConfig,
+  transformCss,
+  transformJsx,
+  transformSolid,
+  transformSvelte
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/obsidian-plugin-transforms.ts"],"sourcesContent":["/**\n * @file\n *\n * The source transforms every bundler adapter shares, so a feature compiles the same way whichever bundler runs it:\n * Solid's JSX, Svelte components and modules, stylesheets through PostCSS, Tailwind and CSS modules, and WebAssembly\n * modules as bytes. The esbuild, rollup and vite adapters call them in-process; the webpack adapter through the\n * loader it ships, and the parcel adapter through the transformers it generates.\n *\n * Erasable TypeScript only (no enums, no parameter properties), so a webpack loader or a parcel worker can load this\n * module straight from source when the toolkit runs from source.\n */\n\nimport type { TransformOptions as BabelTransformOptions } from '@babel/core';\nimport type {\n  AcceptedPlugin,\n  ProcessOptions\n} from 'postcss';\n\nimport { extractDefaultExportInterop } from '@mnaoumov/typescript-lib/object-utils';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { transform as esbuildTransform } from 'esbuild';\nimport process from 'node:process';\nimport postcss from 'postcss';\nimport postcssLoadConfig_ from 'postcss-load-config';\nimport postcssModules_ from 'postcss-modules';\n\nimport type { ObsidianPluginStylesOptions } from './obsidian-plugin-features.ts';\n\nimport {\n  importOptionalPeer,\n  isCssModuleFile\n} from './obsidian-plugin-features.ts';\n\nconst postcssLoadConfig = extractDefaultExportInterop(postcssLoadConfig_);\nconst postcssModules = extractDefaultExportInterop(postcssModules_);\n\n/**\n * Parameters for {@link loadPostcssConfig}.\n */\nexport interface LoadPostcssConfigParams {\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.\n   */\n  readonly projectFolder?: string | undefined;\n\n  /**\n   * The stylesheet options.\n   */\n  readonly styles: ObsidianPluginStylesOptions;\n}\n\n/**\n * What {@link loadPostcssConfig} loaded.\n */\nexport interface PostcssConfig {\n  /**\n   * The files the configuration came from, for a watch build to watch.\n   */\n  readonly dependencies: readonly string[];\n\n  /**\n   * The process options of the project's configuration (a custom parser or syntax, say).\n   */\n  readonly options: ProcessOptions;\n\n  /**\n   * The plugins, in the order they run.\n   */\n  readonly plugins: readonly AcceptedPlugin[];\n}\n\n/**\n * A source map, as the transforms hand it over: the decoded JSON of a version 3 source map.\n */\nexport interface SourceMapLike {\n  /**\n   * The encoded mappings.\n   */\n  readonly mappings: string;\n\n  /**\n   * The original sources.\n   */\n  readonly sources: readonly string[];\n\n  /**\n   * The source map version.\n   */\n  readonly version: number;\n}\n\n/**\n * Parameters for {@link transformCss}.\n */\nexport interface TransformCssParams {\n  /**\n   * The stylesheet's path.\n   */\n  readonly filePath: string;\n\n  /**\n   * Whether `*.module.css` files are scoped here. A bundler that scopes CSS modules itself passes `false`.\n   */\n  readonly isCssModuleScoped: boolean;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.\n   */\n  readonly projectFolder?: string | undefined;\n\n  /**\n   * The stylesheet's contents.\n   */\n  readonly source: string;\n\n  /**\n   * The stylesheet options.\n   */\n  readonly styles: ObsidianPluginStylesOptions;\n}\n\n/**\n * The CSS {@link transformCss} produced.\n */\nexport interface TransformedCss {\n  /**\n   * The stylesheet.\n   */\n  readonly css: string;\n\n  /**\n   * The files besides the stylesheet that the result depends on, for a watch build to watch: a PostCSS configuration,\n   * or a stylesheet a plugin inlined.\n   */\n  readonly dependencies: readonly string[];\n\n  /**\n   * The scoped class names by their original ones, for a CSS module; `undefined` for an ordinary stylesheet.\n   */\n  readonly moduleExports: Readonly<Record<string, string>> | undefined;\n}\n\n/**\n * A JavaScript module a transform produced.\n */\nexport interface TransformedModule {\n  /**\n   * The JavaScript code.\n   */\n  readonly code: string;\n\n  /**\n   * Its source map, or `undefined` when there is none.\n   */\n  readonly map: SourceMapLike | undefined;\n}\n\n/**\n * Parameters for {@link transformJsx}.\n */\nexport interface TransformJsxParams extends TransformModuleParams {\n  /**\n   * The package that supplies the automatic JSX runtime: `react` or `preact`.\n   */\n  readonly jsxImportSource: string;\n}\n\n/**\n * Parameters of a transform that compiles one module.\n */\nexport interface TransformModuleParams {\n  /**\n   * The source code.\n   */\n  readonly code: string;\n\n  /**\n   * The source file's path.\n   */\n  readonly filePath: string;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder the framework's packages are resolved from. Defaults to the project root.\n   */\n  readonly projectFolder?: string;\n}\n\n/**\n * Parameters for {@link transformSolid}.\n */\nexport type TransformSolidParams = TransformModuleParams;\n\n/**\n * Parameters for {@link transformSvelte}.\n */\nexport type TransformSvelteParams = TransformModuleParams;\n\ninterface BabelCoreLike {\n  transformAsync: (code: string, options: BabelTransformOptions) => Promise<BabelResultLike | null>;\n}\n\ninterface BabelResultLike {\n  readonly code?: null | string;\n  readonly map?: null | SourceMapLike;\n}\n\ninterface PostcssDependencyMessage {\n  readonly file?: string;\n  readonly type: string;\n}\n\ninterface SvelteCompileOptionsLike extends SvelteModuleCompileOptionsLike {\n  readonly css: 'injected';\n}\n\ninterface SvelteCompileResultLike {\n  readonly js: TransformedModule;\n}\n\ninterface SvelteCompilerLike {\n  compile: (source: string, options: SvelteCompileOptionsLike) => SvelteCompileResultLike;\n  compileModule: (source: string, options: SvelteModuleCompileOptionsLike) => SvelteCompileResultLike;\n}\n\ninterface SvelteModuleCompileOptionsLike {\n  readonly dev: boolean;\n  readonly filename: string;\n  readonly generate: 'client';\n}\n\ninterface TailwindPostcssModule {\n  readonly default: (options?: TailwindPostcssOptions) => AcceptedPlugin;\n}\n\ninterface TailwindPostcssOptions {\n  readonly base?: string;\n  readonly optimize?: boolean;\n}\n\nconst SVELTE_MODULE_PATTERN = /\\.svelte\\.[cm]?[jt]s$/iu;\nconst TYPESCRIPT_MODULE_PATTERN = /\\.[cm]?ts$/iu;\nconst TAILWIND_POSTCSS_PLUGIN_NAME = '@tailwindcss/postcss';\n\n/**\n * Appends a source map to a module's code as an inline `sourceMappingURL` comment, which is how a bundler that\n * reads a loaded file's own source map takes it.\n *\n * @param module - The module.\n * @returns The code, with the source map inlined when there is one.\n */\nexport function appendInlineSourceMap(module: TransformedModule): string {\n  if (!module.map) {\n    return module.code;\n  }\n  const base64 = Buffer.from(JSON.stringify(module.map), 'utf-8').toString('base64');\n  return `${module.code}\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64}\\n`;\n}\n\n/**\n * Builds the JavaScript module a CSS module's import resolves to: its scoped class names, by their original ones, as\n * the default export.\n *\n * @param moduleExports - The scoped class names.\n * @returns The module's code.\n */\nexport function getCssModuleCode(moduleExports: Readonly<Record<string, string>>): string {\n  return `export default ${JSON.stringify(moduleExports)};\\n`;\n}\n\n/**\n * Builds the JavaScript module a `.wasm` import resolves to: the WebAssembly module's bytes as a `Uint8Array`\n * default export, inlined as base64, because an Obsidian release ships `main.js` and nothing beside it.\n *\n * @param bytes - The WebAssembly module's bytes.\n * @returns The module's code.\n */\nexport function getWasmModuleCode(bytes: Uint8Array): string {\n  const base64 = Buffer.from(bytes).toString('base64');\n  return `const binary = atob(${JSON.stringify(base64)});\nconst bytes = new Uint8Array(binary.length);\nfor (let i = 0; i < binary.length; i++) {\n  bytes[i] = binary.charCodeAt(i);\n}\nexport default bytes;\n`;\n}\n\n/**\n * Loads the PostCSS plugins a stylesheet goes through, without the CSS-module scoping: the project's PostCSS\n * configuration when `postcss` is on, and Tailwind ahead of it when `tailwind` is on and the configuration does not\n * already run it.\n *\n * @param params - The {@link LoadPostcssConfigParams}.\n * @returns A {@link Promise} that resolves to the {@link PostcssConfig}; its `plugins` is empty when neither applies.\n * @throws If `postcss` is on and the project has no PostCSS configuration.\n */\nexport async function loadPostcssConfig(params: LoadPostcssConfigParams): Promise<PostcssConfig> {\n  const { isProductionBuild, projectFolder, styles } = params;\n  const plugins: AcceptedPlugin[] = [];\n  const dependencies: string[] = [];\n  let options: ProcessOptions = {};\n\n  if (styles.postcss) {\n    let config: postcssLoadConfig_.Result;\n    try {\n      config = await postcssLoadConfig({ cwd: projectFolder ?? process.cwd(), env: isProductionBuild ? 'production' : 'development' }, projectFolder);\n    } catch (error) {\n      throw new Error('The `styles.postcss` build option needs a PostCSS configuration (`postcss.config.mjs`, `.postcssrc.json`, ...) in the project.', {\n        cause: error\n      });\n    }\n    plugins.push(...config.plugins as AcceptedPlugin[]);\n    options = config.options;\n    dependencies.push(config.file);\n  }\n\n  if (styles.tailwind && plugins.every((plugin) => !isTailwindPlugin(plugin))) {\n    const { default: tailwind } = await importOptionalPeer<TailwindPostcssModule>({\n      feature: 'styles.tailwind',\n      packageName: TAILWIND_POSTCSS_PLUGIN_NAME,\n      ...(projectFolder !== undefined && { projectFolder })\n    });\n    plugins.unshift(tailwind({ ...(projectFolder !== undefined && { base: projectFolder }), optimize: isProductionBuild }));\n  }\n\n  return { dependencies, options, plugins };\n}\n\n/**\n * Runs a stylesheet through the pipeline its options ask for: the project's PostCSS configuration, Tailwind, and the\n * CSS-module scoping of a `*.module.css` file.\n *\n * @param params - The {@link TransformCssParams}.\n * @returns A {@link Promise} that resolves to the {@link TransformedCss}.\n * @throws If `postcss` is on and the project has no PostCSS configuration.\n */\nexport async function transformCss(params: TransformCssParams): Promise<TransformedCss> {\n  const { filePath, isCssModuleScoped, source, styles } = params;\n  const postcssConfig = await loadPostcssConfig(params);\n  const plugins = [...postcssConfig.plugins];\n  const dependencies = [...postcssConfig.dependencies];\n\n  let moduleExports: Record<string, string> | undefined;\n  if (styles.cssModules && isCssModuleScoped && isCssModuleFile(filePath)) {\n    plugins.push(postcssModules({\n      getJSON(_cssFileName, json): void {\n        moduleExports = json;\n      }\n    }));\n  }\n\n  if (plugins.length === 0) {\n    return { css: source, dependencies, moduleExports };\n  }\n\n  const result = await postcss(plugins).process(source, { ...postcssConfig.options, from: filePath, map: false });\n  for (const message of result.messages as PostcssDependencyMessage[]) {\n    if (message.type === 'dependency' && message.file !== undefined) {\n      dependencies.push(message.file);\n    }\n  }\n  return { css: result.css, dependencies, moduleExports };\n}\n\n/**\n * Compiles a React or Preact JSX or TSX module with the automatic JSX runtime, for a bundler that does not take the\n * runtime from the project's tsconfig (parcel does not follow its `extends`).\n *\n * @param params - The {@link TransformJsxParams}.\n * @returns A {@link Promise} that resolves to the compiled module.\n */\nexport async function transformJsx(params: TransformJsxParams): Promise<TransformedModule> {\n  const { code, filePath, jsxImportSource } = params;\n  const result = await esbuildTransform(code, {\n    jsx: 'automatic',\n    jsxImportSource,\n    loader: /\\.tsx$/iu.test(filePath) ? 'tsx' : 'jsx',\n    sourcefile: filePath,\n    sourcemap: 'external'\n  });\n  return { code: result.code, map: JSON.parse(result.map) as SourceMapLike };\n}\n\n/**\n * Compiles a Solid JSX or TSX module: esbuild strips the TypeScript and keeps the JSX, then `babel-preset-solid`\n * compiles the JSX into DOM expressions.\n *\n * @param params - The {@link TransformModuleParams}.\n * @returns A {@link Promise} that resolves to the compiled module.\n * @throws If Babel produced no code.\n */\nexport async function transformSolid(params: TransformSolidParams): Promise<TransformedModule> {\n  const { code, filePath } = params;\n  const feature = 'framework: \\'solid\\'';\n  const projectFolderOption = params.projectFolder === undefined ? {} : { projectFolder: params.projectFolder };\n  const babel = extractDefaultExportInterop(await importOptionalPeer<BabelCoreLike>({ feature, packageName: '@babel/core', ...projectFolderOption }));\n  const solidPreset = extractDefaultExportInterop(await importOptionalPeer<object>({ feature, packageName: 'babel-preset-solid', ...projectFolderOption }));\n\n  const stripped = await esbuildTransform(code, {\n    jsx: 'preserve',\n    loader: /\\.tsx$/iu.test(filePath) ? 'tsx' : 'jsx',\n    sourcefile: filePath,\n    sourcemap: 'external'\n  });\n\n  const result = await babel.transformAsync(stripped.code, {\n    babelrc: false,\n    configFile: false,\n    filename: filePath,\n    inputSourceMap: JSON.parse(stripped.map) as BabelTransformOptions['inputSourceMap'],\n    presets: [[solidPreset, { generate: 'dom', hydratable: false }]],\n    sourceMaps: true\n  });\n  /* v8 ignore start -- Babel returns no code only when a plugin drops the file, which the Solid preset never does. */\n  if (!result?.code) {\n    throw new Error(`Babel produced no code for ${filePath}`);\n  }\n  /* v8 ignore stop */\n  // With `sourceMaps` on, Babel always returns a source map.\n  return { code: result.code, map: ensureNonNullable(result.map, `Babel produced no source map for ${filePath}`) };\n}\n\n/**\n * Compiles a Svelte component (`.svelte`), with its styles injected by the component itself, or a Svelte module\n * (`.svelte.ts`, `.svelte.js`), whose TypeScript esbuild strips first.\n *\n * @param params - The {@link TransformModuleParams}.\n * @returns A {@link Promise} that resolves to the compiled module.\n */\nexport async function transformSvelte(params: TransformSvelteParams): Promise<TransformedModule> {\n  const { code, filePath, isProductionBuild } = params;\n  const compiler = extractDefaultExportInterop(\n    await importOptionalPeer<SvelteCompilerLike>({\n      feature: 'framework: \\'svelte\\'',\n      packageName: 'svelte',\n      specifier: 'svelte/compiler',\n      ...(params.projectFolder !== undefined && { projectFolder: params.projectFolder })\n    })\n  );\n  const moduleOptions: SvelteModuleCompileOptionsLike = { dev: !isProductionBuild, filename: filePath, generate: 'client' };\n\n  if (SVELTE_MODULE_PATTERN.test(filePath)) {\n    let javaScript = code;\n    if (TYPESCRIPT_MODULE_PATTERN.test(filePath)) {\n      const stripped = await esbuildTransform(code, { loader: 'ts', sourcefile: filePath });\n      javaScript = stripped.code;\n    }\n    return compiler.compileModule(javaScript, moduleOptions).js;\n  }\n\n  return compiler.compile(code, { ...moduleOptions, css: 'injected' }).js;\n}\n\nfunction isTailwindPlugin(plugin: AcceptedPlugin): boolean {\n  return typeof plugin === 'object' && 'postcssPlugin' in plugin && plugin.postcssPlugin === TAILWIND_POSTCSS_PLUGIN_NAME;\n}\n"],"mappings":"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","names":[]}