@mnaoumov/obsidian-dev-toolkit 3.2.0 → 3.2.1

package/dist/lib/esm/bundlers/parcel.mjs

@@ -68,6 +68,7 @@ const RESOLVER_FILE_NAME = "obsidian-plugin-resolver.cjs";
 const NAMER_FILE_NAME = "obsidian-plugin-namer.cjs";
 const INLINE_IMPORTS_FILE_NAME = "obsidian-plugin-inline-imports.cjs";
 const OPTIMIZER_FILE_NAME = "obsidian-plugin-optimizer.cjs";
+const PRE_MINIFY_FILE_NAME = "obsidian-plugin-pre-minify.cjs";
 const FEATURES_FILE_NAME = "obsidian-plugin-features.cjs";
 const JSON_INDENT = 2;
 async function build(options) {
@@ -144,7 +145,7 @@ function getParcelConfigFiles(params) {
     extends: consumerParcelrcPath ?? "@parcel/config-default",
     namers: [`./${NAMER_FILE_NAME}`, "..."],
     optimizers: {
-      "*.js": ["...", `./${OPTIMIZER_FILE_NAME}`]
+      "*.js": [`./${PRE_MINIFY_FILE_NAME}`, "...", `./${OPTIMIZER_FILE_NAME}`]
     },
     resolvers: [`./${RESOLVER_FILE_NAME}`, "..."],
     transformers
@@ -284,20 +285,123 @@ module.exports = new Optimizer({
 `,
     [PARCELRC]: `${JSON.stringify(parcelrc, null, JSON_INDENT)}
 `,
-    [RESOLVER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Leaves the modules Obsidian supplies at runtime to require(). */
+    // `String.raw`, so the line breaks below reach the file as escapes.
+    [PRE_MINIFY_FILE_NAME]: String.raw`/*
+ * Generated by @mnaoumov/obsidian-dev-toolkit. Runs before parcel's own optimizers, on the JavaScript bundle.
+ *
+ * A scope-hoisted library bundle require()s every bundle it references, the stylesheet included, and Obsidian
+ * loads styles.css itself, beside main.js, where a require() cannot reach it. The line is blanked rather than
+ * removed, so a source map still lines up.
+ *
+ * A scope-hoisted CommonJS bundle also declares every module's bindings at its top level, under long names such
+ * as $c5899aeb4caadf27$var$taskIdCounter, and parcel minifies it as a script, where the minifier may not rename
+ * a top-level binding, since in a script it is a global. Obsidian evaluates main.js as the body of a function, so
+ * wrapping the bundle in an arrow function changes nothing at runtime (an arrow keeps this and arguments) and
+ * lets the minifier rename all of them: Solid's fixture build is 70 KB without this and 10 KB with it.
+ */
+const { Optimizer } = require('@parcel/plugin');
+
+const STYLESHEET_REQUIRE = ${JSON.stringify(`require('./${ObsidianPluginRepoPaths.StylesCss}');
+`)};
+
+async function readContents(contents) {
+  if (typeof contents === 'string') {
+    return contents;
+  }
+  if (Buffer.isBuffer(contents)) {
+    return contents.toString('utf-8');
+  }
+  const chunks = [];
+  for await (const chunk of contents) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+module.exports = new Optimizer({
+  async optimize({ bundle, contents, map }) {
+    const code = (await readContents(contents)).replace(STYLESHEET_REQUIRE, '\n');
+    if (!bundle.env.shouldOptimize) {
+      return { contents: code, map };
+    }
+    if (map) {
+      map.offsetLines(1, 1);
+    }
+    return { contents: '(() => {\n' + code + '\n})();\n', map };
+  }
+});
+`,
+    [RESOLVER_FILE_NAME]: `/*
+ * Generated by @mnaoumov/obsidian-dev-toolkit. Leaves the modules Obsidian supplies at runtime to require(), and
+ * resolves everything else the way @parcel/resolver-default does, with the browser's export conditions.
+ *
+ * Parcel resolves an electron-renderer target with the node and electron conditions beside browser, and an exports
+ * map is matched in the package's own key order, so a package listing node first (Vue, Svelte, Solid, fflate) would
+ * hand over its Node build: several times the code, and one that may not load on mobile. The Node builtins need no
+ * node condition to stay external, since they are in the externals below.
+ */
 const { Resolver } = require('@parcel/plugin');
+const { dirname } = require('node:path');
 
 const EXTERNALS = new Set(${JSON.stringify(OBSIDIAN_PLUGIN_EXTERNALS)});
 
+function getBrowserEnvironment(env) {
+  return {
+    context: env.context,
+    id: env.id + ':obsidian-dev-toolkit-browser-conditions',
+    includeNodeModules: env.includeNodeModules,
+    isBrowser: () => true,
+    isElectron: () => false,
+    isLibrary: env.isLibrary,
+    isNode: () => false,
+    isWorker: () => env.isWorker(),
+    isWorklet: () => env.isWorklet()
+  };
+}
+
 function getPackageName(specifier) {
   const segments = specifier.split('/');
   return specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];
 }
 
+// @parcel/node-resolver-core is what @parcel/resolver-default runs, reached through the packages that install it.
+function loadNodeResolver() {
+  let folder = __dirname;
+  for (const packageName of ['@parcel/config-default', '@parcel/resolver-default']) {
+    folder = dirname(require.resolve(packageName + '/package.json', { paths: [folder] }));
+  }
+  return require(require.resolve('@parcel/node-resolver-core', { paths: [folder] })).default;
+}
+
 module.exports = new Resolver({
-  resolve({ specifier }) {
+  async loadConfig({ config, logger, options }) {
+    const packageConfig = await config.getConfig([], { packageKey: '@parcel/resolver-default' });
+    const NodeResolver = loadNodeResolver();
+    return new NodeResolver({
+      fs: options.inputFS,
+      logger,
+      mode: options.mode,
+      packageExports: packageConfig?.contents?.packageExports ?? false,
+      packageManager: options.packageManager,
+      projectRoot: options.projectRoot,
+      shouldAutoInstall: options.shouldAutoInstall
+    });
+  },
+  resolve({ config: nodeResolver, dependency, specifier }) {
     const isExternal = specifier.startsWith('node:') || EXTERNALS.has(specifier) || EXTERNALS.has(getPackageName(specifier));
-    return isExternal ? { isExcluded: true } : null;
+    if (isExternal) {
+      return { isExcluded: true };
+    }
+    return nodeResolver.resolve({
+      env: getBrowserEnvironment(dependency.env),
+      filename: specifier,
+      loc: dependency.loc,
+      packageConditions: dependency.packageConditions,
+      parent: dependency.resolveFrom,
+      range: dependency.range,
+      sourcePath: dependency.sourcePath,
+      specifierType: dependency.specifierType
+    });
   }
 });
 `
@@ -323,6 +427,7 @@ function getParcelOptions(params) {
       // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.
       distDir: buildContext.distFolder,
       shouldOptimize: buildContext.isProductionBuild,
+      shouldScopeHoist: true,
       sourceMaps: !buildContext.isProductionBuild
     },
     entries: buildContext.entryPoint,
@@ -358,4 +463,4 @@ export {
   getParcelConfigFiles,
   getParcelOptions
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/parcel.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with parcel: `build()` and `dev()`, the same two entry points the esbuild\n * builder has, producing the same `main.js` + `styles.css` + `manifest.json` layout.\n *\n * Parcel takes no `external` list and no output file name, only plugins named in a `.parcelrc`. So the\n * build writes a `.parcelrc` of its own into `.parcel-cache`, beside a resolver that leaves\n * Obsidian's modules external, a namer that names the stylesheet `styles.css` and a transformer that keeps\n * dynamic imports inside `main.js`, and extends the\n * consumer's own `.parcelrc` when there is one (or `@parcel/config-default` when there is none), so every\n * transformer the consumer configured still applies.\n *\n * `@parcel/core`, `@parcel/plugin` and `@parcel/config-default` are optional peer dependencies, loaded\n * only when a parcel build runs, so a plugin built with esbuild installs nothing extra.\n */\n\nimport type {\n  BuildEvent,\n  InitialParcelOptions,\n  TargetDescriptor\n} from '@parcel/types';\n\nimport { CliTaskResult } from '@mnaoumov/typescript-dev-toolkit/cli-utils';\nimport { npmRunOptional } from '@mnaoumov/typescript-dev-toolkit/npm-run';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport {\n  extname,\n  join,\n  relative,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  OBSIDIAN_PLUGIN_EXTERNALS,\n  resolveFromRoot,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport {\n  getFrameworkDefines,\n  getJsxImportSource,\n  isPostcssNeeded\n} from './obsidian-plugin-features.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\n\n/**\n * Options for {@link buildObsidianPluginWithParcel}.\n */\nexport interface BuildObsidianPluginWithParcelParams extends BuildOptions {\n  /**\n   * A build mode, either `Development` or `Production`.\n   */\n  readonly mode: BuildMode;\n}\n\n/**\n * Options for {@link build} and {@link dev}.\n */\nexport interface BuildOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * Customizes the options handed to parcel's `Parcel` class.\n   */\n  readonly customizeParcelOptions?: (options: InitialParcelOptions) => InitialParcelOptions;\n}\n\n/**\n * Parameters for {@link getParcelConfigFiles}.\n */\nexport interface GetParcelConfigFilesParams {\n  /**\n   * The consumer's own `.parcelrc`, relative to the generated configuration's folder, or `undefined` when the project\n   * has none.\n   */\n  readonly consumerParcelrcPath: string | undefined;\n\n  /**\n   * The build features.\n   */\n  readonly features?: ObsidianPluginFeatureOptions;\n}\n\n/**\n * Parameters for {@link getParcelOptions}.\n */\nexport interface GetParcelOptionsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * Parcel's cache folder. Named explicitly because parcel otherwise takes the folder of the nearest\n   * lockfile for the project root, which in a workspace is not the plugin's.\n   */\n  readonly cacheFolder: string;\n\n  /**\n   * The generated `.parcelrc`.\n   */\n  readonly configPath: string;\n}\n\n/**\n * The files of the generated parcel configuration, by file name.\n */\nexport type ParcelConfigFiles = Readonly<Record<string, string>>;\n\n// Inside parcel's own cache folder: parcel refuses relative plugins in a config under `node_modules` (it\n// takes such a config for a published package), and it never watches its cache folder, so regenerating\n// these files on every build cannot trigger a rebuild.\nconst PARCEL_CACHE_FOLDER = '.parcel-cache';\nconst GENERATED_PARCEL_CONFIG_FOLDER = `${PARCEL_CACHE_FOLDER}/obsidian-dev-toolkit`;\nconst PARCELRC = '.parcelrc';\n\n/**\n * One diagnostic of a {@link ParcelErrorLike}.\n */\ninterface ParcelErrorDiagnostic {\n  readonly message: string;\n}\n\n/**\n * What parcel throws when a build fails: an error carrying its diagnostics.\n */\ninterface ParcelErrorLike {\n  readonly diagnostics?: readonly ParcelErrorDiagnostic[];\n}\nconst RESOLVER_FILE_NAME = 'obsidian-plugin-resolver.cjs';\nconst NAMER_FILE_NAME = 'obsidian-plugin-namer.cjs';\nconst INLINE_IMPORTS_FILE_NAME = 'obsidian-plugin-inline-imports.cjs';\nconst OPTIMIZER_FILE_NAME = 'obsidian-plugin-optimizer.cjs';\nconst FEATURES_FILE_NAME = 'obsidian-plugin-features.cjs';\nconst JSON_INDENT = 2;\n\n/* v8 ignore start -- Runs a real parcel build; exercised by the bundler integration test. */\n/**\n * Builds the Obsidian plugin in production mode using parcel.\n *\n * @param options - Optional build options.\n * @returns A {@link Promise} that resolves when the build is complete.\n */\nexport async function build(options?: BuildOptions): Promise<void> {\n  const result = await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Production });\n  result.throwOnFailure();\n}\n\n/**\n * Builds the Obsidian plugin with parcel, once for a production build, or watching for a development one.\n *\n * Runs the project's `build:compile` script first when it has one, as the esbuild builder does, since\n * parcel strips TypeScript types without checking them.\n *\n * @param params - The {@link BuildObsidianPluginWithParcelParams}.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function buildObsidianPluginWithParcel(params: BuildObsidianPluginWithParcelParams): Promise<CliTaskResult> {\n  await npmRunOptional('build:compile');\n  const buildContext = await resolveObsidianPluginBuildContext(params);\n  await cleanObsidianPluginDistFolder(buildContext.distFolder);\n  await completeObsidianPluginDistFolder(buildContext);\n\n  const configFolder = resolveFromRoot(GENERATED_PARCEL_CONFIG_FOLDER);\n  const consumerParcelrcPath = resolveFromRoot(PARCELRC);\n  await mkdir(configFolder, { recursive: true });\n  const configFiles = getParcelConfigFiles({\n    consumerParcelrcPath: existsSync(consumerParcelrcPath) ? toPosixPath(relative(configFolder, consumerParcelrcPath)) : undefined,\n    features: params\n  });\n  for (const [fileName, contents] of Object.entries(configFiles)) {\n    const filePath = join(configFolder, fileName);\n    // Rewritten only when it changed: parcel invalidates its cache on a config file's modification time.\n    if (!existsSync(filePath) || await readFile(filePath, 'utf-8') !== contents) {\n      await writeFile(filePath, contents, 'utf-8');\n    }\n  }\n\n  const { Parcel } = await import('@parcel/core');\n  const parcelOptions = getParcelOptions({ buildContext, cacheFolder: resolveFromRoot(PARCEL_CACHE_FOLDER), configPath: join(configFolder, PARCELRC) });\n  const bundler = new Parcel(params.customizeParcelOptions?.(parcelOptions) ?? parcelOptions);\n\n  if (buildContext.isProductionBuild) {\n    try {\n      const { buildTime, bundleGraph } = await bundler.run();\n      console.warn(`Built ${String(bundleGraph.getBundles().length)} bundle(s) with parcel in ${String(buildTime)} ms.`);\n      return CliTaskResult.Success();\n    } catch (error) {\n      console.error(formatParcelError(error));\n      return CliTaskResult.Failure();\n    }\n  }\n\n  await bundler.watch((error, event) => {\n    if (error) {\n      console.error(formatParcelError(error));\n      return;\n    }\n    handleWatchEvent(event, buildContext);\n  });\n  return CliTaskResult.DoNotExit();\n}\n\n/**\n * Builds the Obsidian plugin in development mode using parcel, watching for changes and deploying every\n * successful rebuild into the vault.\n *\n * @param options - Optional build options.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the build result.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares BuildOptions with build().\nexport async function dev(options?: BuildOptions): Promise<CliTaskResult> {\n  return await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Development });\n}\n/* v8 ignore stop */\n\n/**\n * Generates the files of the parcel configuration the build runs with.\n *\n * The build features add pipelines that run the toolkit's shared transforms, through one generated transformer that\n * loads them from the toolkit: Solid's `.jsx` / `.tsx`, Svelte's `.svelte` / `.svelte.ts` / `.svelte.js`, `.wasm`,\n * and with `styles.postcss` or `styles.tailwind` every stylesheet, in place of parcel's own PostCSS step. React and\n * Preact JSX is compiled here too, since parcel reads the JSX runtime from a tsconfig without following its `extends`,\n * and with any framework every script has the framework's compile-time constants replaced. Parcel compiles Vue with\n * `@parcel/transformer-vue` and scopes `*.module.css` itself, so those need no pipeline here.\n *\n * @param params - The {@link GetParcelConfigFilesParams}.\n * @returns The files, by file name.\n */\nexport function getParcelConfigFiles(params: GetParcelConfigFilesParams): ParcelConfigFiles {\n  const { consumerParcelrcPath, features = {} } = params;\n  const featureTransformer = `./${FEATURES_FILE_NAME}`;\n  const transformers: Record<string, string[]> = {};\n  if (features.framework === 'svelte') {\n    transformers['*.svelte'] = [featureTransformer];\n    transformers['*.svelte.{js,ts}'] = [featureTransformer, `./${INLINE_IMPORTS_FILE_NAME}`, '...'];\n  }\n  if (features.framework === 'solid' || getJsxImportSource(features.framework) !== undefined) {\n    transformers['*.{jsx,tsx}'] = [featureTransformer];\n  }\n  if (features.wasm) {\n    transformers['*.wasm'] = [featureTransformer];\n  }\n  if (isPostcssNeeded(features.styles)) {\n    transformers['*.{css,pcss}'] = [featureTransformer, '@parcel/transformer-css'];\n  }\n  const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild: true });\n  transformers['*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'] = [\n    ...Object.keys(defines).length > 0 ? [featureTransformer] : [],\n    `./${INLINE_IMPORTS_FILE_NAME}`,\n    '...'\n  ];\n\n  const parcelrc = {\n    extends: consumerParcelrcPath ?? '@parcel/config-default',\n    namers: [`./${NAMER_FILE_NAME}`, '...'],\n    optimizers: {\n      '*.js': ['...', `./${OPTIMIZER_FILE_NAME}`]\n    },\n    resolvers: [`./${RESOLVER_FILE_NAME}`, '...'],\n    transformers\n  };\n\n  return {\n    [FEATURES_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs the toolkit's shared transforms for the build features, loaded\n * from the toolkit itself, so parcel compiles each feature the way every other bundler adapter does.\n */\nconst { Transformer } = require('@parcel/plugin');\n\nconst FEATURES_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl('obsidian-plugin-features'))};\nconst TRANSFORMS_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl('obsidian-plugin-transforms'))};\nconst FRAMEWORK = ${JSON.stringify(features.framework ?? null)};\nconst STYLES = ${JSON.stringify(features.styles ?? {})};\n\nmodule.exports = new Transformer({\n  async transform({ asset, options }) {\n    const { getFeatureFileKind, getFrameworkDefines, getJsxImportSource, replaceDefines } = await import(FEATURES_MODULE_URL);\n    const transforms = await import(TRANSFORMS_MODULE_URL);\n    const filePath = asset.filePath;\n    const isProductionBuild = options.mode === 'production';\n    const defines = getFrameworkDefines({ framework: FRAMEWORK ?? undefined, isProductionBuild });\n    switch (getFeatureFileKind(filePath)) {\n      case 'jsx': {\n        const code = await asset.getCode();\n        const jsxImportSource = getJsxImportSource(FRAMEWORK ?? undefined);\n        const result = FRAMEWORK === 'solid'\n          ? await transforms.transformSolid({ code, filePath, isProductionBuild })\n          : await transforms.transformJsx({ code, filePath, isProductionBuild, jsxImportSource });\n        asset.setCode(replaceDefines(result.code, defines));\n        asset.type = 'js';\n        break;\n      }\n      case 'stylesheet': {\n        const result = await transforms.transformCss({ filePath, isCssModuleScoped: false, isProductionBuild, source: await asset.getCode(), styles: STYLES });\n        asset.setCode(result.css);\n        for (const dependency of result.dependencies) {\n          asset.invalidateOnFileChange(dependency);\n        }\n        break;\n      }\n      case 'svelte': {\n        const result = await transforms.transformSvelte({ code: await asset.getCode(), filePath, isProductionBuild });\n        asset.setCode(replaceDefines(result.code, defines));\n        asset.type = 'js';\n        break;\n      }\n      case 'wasm':\n        asset.setCode(transforms.getWasmModuleCode(await asset.getBuffer()));\n        asset.type = 'js';\n        break;\n      default: {\n        // A framework's runtime reads process.env.NODE_ENV, which parcel leaves alone in an electron-renderer library.\n        const code = await asset.getCode();\n        const replaced = replaceDefines(code, defines);\n        if (replaced !== code) {\n          asset.setCode(replaced);\n        }\n        break;\n      }\n    }\n    return [asset];\n  }\n});\n`,\n    // `String.raw`, so the regular expression below reaches the file with its backslashes intact.\n    [INLINE_IMPORTS_FILE_NAME]: String.raw`/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Keeps every dynamic import() inside main.js.\n *\n * Obsidian loads a plugin's main.js and nothing beside it, and parcel makes every import() a bundle of its\n * own with no option to inline one. This rewrites import('<literal>') into a require() inside an async\n * arrow, before parcel's own JavaScript transformer runs: the module still evaluates only when that code\n * runs, and the promise still rejects when evaluation throws. Only a plain string specifier is rewritten,\n * since a computed one cannot be bundled by any bundler.\n */\nconst { Transformer } = require('@parcel/plugin');\n\nconst DYNAMIC_IMPORT = /\\bimport\\(\\s*([\"'])([^\"'\\x60\\n\\\\]+)\\1\\s*\\)/gu;\n\nmodule.exports = new Transformer({\n  async transform({ asset }) {\n    const source = await asset.getCode();\n    if (source.includes('import(')) {\n      asset.setCode(source.replace(DYNAMIC_IMPORT, (_match, quote, specifier) => '(async () => require(' + quote + specifier + quote + '))()'));\n    }\n    return [asset];\n  }\n});\n`,\n    [NAMER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Obsidian loads a plugin's stylesheet from styles.css and nothing else. */\nconst { Namer } = require('@parcel/plugin');\n\nmodule.exports = new Namer({\n  name({ bundle }) {\n    return bundle.type === 'css' ? '${ObsidianPluginRepoPaths.StylesCss}' : null;\n  }\n});\n`,\n    [OPTIMIZER_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs after parcel's own optimizers, on the JavaScript bundle.\n *\n * Obsidian evaluates main.js as the body of function (require, module, exports), with a module object that\n * has no require of its own, and parcel's runtime reaches every external module through module.require.\n * Without the first line below, the very first require('obsidian') throws \"Cannot find module\". The banner\n * goes in here too, after minification, which would otherwise strip it as an ordinary comment.\n */\nconst { Optimizer } = require('@parcel/plugin');\n\nconst PREAMBLE = ${JSON.stringify(`${getObsidianPluginBanner('parcel')}if (typeof module === 'object' && typeof module.require !== 'function') { module.require = require; }\\n`)};\nconst PREAMBLE_LINE_COUNT = ${String(getObsidianPluginBanner('parcel').split('\\n').length)};\n\nasync function readContents(contents) {\n  if (typeof contents === 'string') {\n    return contents;\n  }\n  if (Buffer.isBuffer(contents)) {\n    return contents.toString('utf-8');\n  }\n  const chunks = [];\n  for await (const chunk of contents) {\n    chunks.push(Buffer.from(chunk));\n  }\n  return Buffer.concat(chunks).toString('utf-8');\n}\n\nmodule.exports = new Optimizer({\n  async optimize({ contents, map }) {\n    const code = await readContents(contents);\n    if (map) {\n      map.offsetLines(1, PREAMBLE_LINE_COUNT);\n    }\n    return { contents: PREAMBLE + code, map };\n  }\n});\n`,\n    [PARCELRC]: `${JSON.stringify(parcelrc, null, JSON_INDENT)}\\n`,\n    [RESOLVER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Leaves the modules Obsidian supplies at runtime to require(). */\nconst { Resolver } = require('@parcel/plugin');\n\nconst EXTERNALS = new Set(${JSON.stringify(OBSIDIAN_PLUGIN_EXTERNALS)});\n\nfunction getPackageName(specifier) {\n  const segments = specifier.split('/');\n  return specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];\n}\n\nmodule.exports = new Resolver({\n  resolve({ specifier }) {\n    const isExternal = specifier.startsWith('node:') || EXTERNALS.has(specifier) || EXTERNALS.has(getPackageName(specifier));\n    return isExternal ? { isExcluded: true } : null;\n  }\n});\n`\n  };\n}\n\n/**\n * Builds the options handed to parcel's `Parcel` class.\n *\n * The one target is `electron-renderer`, where Obsidian runs a plugin, and CommonJS. Parcel counts that\n * context as both a browser and a node one, and each half matters: node keeps the builtins external, and\n * browser resolves the `browser` export condition. `includeNodeModules` bundles the dependencies, which a\n * node-flavoured context would otherwise leave as `require()` calls nothing installs beside a plugin, and\n * `isLibrary` keeps the entry's default export, which is how Obsidian finds the plugin class.\n *\n * @param params - The {@link GetParcelOptionsParams}.\n * @returns The parcel options.\n */\nexport function getParcelOptions(params: GetParcelOptionsParams): InitialParcelOptions {\n  const { buildContext, cacheFolder, configPath } = params;\n  const target: TargetDescriptor = {\n    context: 'electron-renderer',\n    // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.\n    distDir: buildContext.distFolder,\n    includeNodeModules: true,\n    isLibrary: true,\n    optimize: buildContext.isProductionBuild,\n    outputFormat: 'commonjs',\n    sourceMap: !buildContext.isProductionBuild && { inline: true }\n  };\n\n  return {\n    // eslint-disable-next-line unicorn/name-replacements -- `cacheDir` is the name parcel's API reads.\n    cacheDir: cacheFolder,\n    config: configPath,\n    defaultTargetOptions: {\n      // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.\n      distDir: buildContext.distFolder,\n      shouldOptimize: buildContext.isProductionBuild,\n      sourceMaps: !buildContext.isProductionBuild\n    },\n    entries: buildContext.entryPoint,\n    mode: buildContext.isProductionBuild ? 'production' : 'development',\n    targets: { obsidianPlugin: target }\n  };\n}\n/* v8 ignore start -- Part of the parcel build above. */\nfunction formatParcelError(error: unknown): string {\n  const diagnostics = (error as ParcelErrorLike | undefined)?.diagnostics;\n  if (diagnostics && diagnostics.length > 0) {\n    return diagnostics.map((diagnostic) => diagnostic.message).join('\\n');\n  }\n  return error instanceof Error ? error.stack ?? error.message : String(error);\n}\n\n/**\n * Builds the URL of a module of this folder, in the same form as this one (`.ts` from source, `.mjs` or `.cjs` once\n * built), which the generated transformer imports.\n *\n * @param baseName - The module's file name without its extension.\n * @returns The module's `file:` URL.\n */\nfunction getSiblingModuleUrl(baseName: string): string {\n  return new URL(`${baseName}${extname(new URL(import.meta.url).pathname)}`, import.meta.url).href;\n}\n\nfunction handleWatchEvent(event: BuildEvent | undefined, buildContext: ObsidianPluginBuildContext): void {\n  if (event?.type === 'buildFailure') {\n    console.error(event.diagnostics.map((diagnostic) => diagnostic.message).join('\\n'));\n    return;\n  }\n  if (event?.type !== 'buildSuccess') {\n    return;\n  }\n\n  console.warn(`Rebuilt with parcel in ${String(event.buildTime)} ms.`);\n  invokeAsyncSafely(() => deployToObsidianPluginsFolder(buildContext));\n}\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/parcel.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with parcel: `build()` and `dev()`, the same two entry points the esbuild\n * builder has, producing the same `main.js` + `styles.css` + `manifest.json` layout.\n *\n * Parcel takes no `external` list and no output file name, only plugins named in a `.parcelrc`. So the\n * build writes a `.parcelrc` of its own into `.parcel-cache`, beside a resolver that leaves\n * Obsidian's modules external and resolves packages with the browser's export conditions, a namer that names\n * the stylesheet `styles.css`, a transformer that keeps dynamic imports inside `main.js`, and an optimizer that\n * lets the minifier rename the bundle's top-level bindings, and extends the\n * consumer's own `.parcelrc` when there is one (or `@parcel/config-default` when there is none), so every\n * transformer the consumer configured still applies.\n *\n * `@parcel/core`, `@parcel/plugin` and `@parcel/config-default` are optional peer dependencies, loaded\n * only when a parcel build runs, so a plugin built with esbuild installs nothing extra.\n */\n\nimport type {\n  BuildEvent,\n  InitialParcelOptions,\n  TargetDescriptor\n} from '@parcel/types';\n\nimport { CliTaskResult } from '@mnaoumov/typescript-dev-toolkit/cli-utils';\nimport { npmRunOptional } from '@mnaoumov/typescript-dev-toolkit/npm-run';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport {\n  extname,\n  join,\n  relative,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  OBSIDIAN_PLUGIN_EXTERNALS,\n  resolveFromRoot,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport {\n  getFrameworkDefines,\n  getJsxImportSource,\n  isPostcssNeeded\n} from './obsidian-plugin-features.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\n\n/**\n * Options for {@link buildObsidianPluginWithParcel}.\n */\nexport interface BuildObsidianPluginWithParcelParams extends BuildOptions {\n  /**\n   * A build mode, either `Development` or `Production`.\n   */\n  readonly mode: BuildMode;\n}\n\n/**\n * Options for {@link build} and {@link dev}.\n */\nexport interface BuildOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * Customizes the options handed to parcel's `Parcel` class.\n   */\n  readonly customizeParcelOptions?: (options: InitialParcelOptions) => InitialParcelOptions;\n}\n\n/**\n * Parameters for {@link getParcelConfigFiles}.\n */\nexport interface GetParcelConfigFilesParams {\n  /**\n   * The consumer's own `.parcelrc`, relative to the generated configuration's folder, or `undefined` when the project\n   * has none.\n   */\n  readonly consumerParcelrcPath: string | undefined;\n\n  /**\n   * The build features.\n   */\n  readonly features?: ObsidianPluginFeatureOptions;\n}\n\n/**\n * Parameters for {@link getParcelOptions}.\n */\nexport interface GetParcelOptionsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * Parcel's cache folder. Named explicitly because parcel otherwise takes the folder of the nearest\n   * lockfile for the project root, which in a workspace is not the plugin's.\n   */\n  readonly cacheFolder: string;\n\n  /**\n   * The generated `.parcelrc`.\n   */\n  readonly configPath: string;\n}\n\n/**\n * The files of the generated parcel configuration, by file name.\n */\nexport type ParcelConfigFiles = Readonly<Record<string, string>>;\n\n// Inside parcel's own cache folder: parcel refuses relative plugins in a config under `node_modules` (it\n// takes such a config for a published package), and it never watches its cache folder, so regenerating\n// these files on every build cannot trigger a rebuild.\nconst PARCEL_CACHE_FOLDER = '.parcel-cache';\nconst GENERATED_PARCEL_CONFIG_FOLDER = `${PARCEL_CACHE_FOLDER}/obsidian-dev-toolkit`;\nconst PARCELRC = '.parcelrc';\n\n/**\n * One diagnostic of a {@link ParcelErrorLike}.\n */\ninterface ParcelErrorDiagnostic {\n  readonly message: string;\n}\n\n/**\n * What parcel throws when a build fails: an error carrying its diagnostics.\n */\ninterface ParcelErrorLike {\n  readonly diagnostics?: readonly ParcelErrorDiagnostic[];\n}\nconst RESOLVER_FILE_NAME = 'obsidian-plugin-resolver.cjs';\nconst NAMER_FILE_NAME = 'obsidian-plugin-namer.cjs';\nconst INLINE_IMPORTS_FILE_NAME = 'obsidian-plugin-inline-imports.cjs';\nconst OPTIMIZER_FILE_NAME = 'obsidian-plugin-optimizer.cjs';\nconst PRE_MINIFY_FILE_NAME = 'obsidian-plugin-pre-minify.cjs';\nconst FEATURES_FILE_NAME = 'obsidian-plugin-features.cjs';\nconst JSON_INDENT = 2;\n\n/* v8 ignore start -- Runs a real parcel build; exercised by the bundler integration test. */\n/**\n * Builds the Obsidian plugin in production mode using parcel.\n *\n * @param options - Optional build options.\n * @returns A {@link Promise} that resolves when the build is complete.\n */\nexport async function build(options?: BuildOptions): Promise<void> {\n  const result = await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Production });\n  result.throwOnFailure();\n}\n\n/**\n * Builds the Obsidian plugin with parcel, once for a production build, or watching for a development one.\n *\n * Runs the project's `build:compile` script first when it has one, as the esbuild builder does, since\n * parcel strips TypeScript types without checking them.\n *\n * @param params - The {@link BuildObsidianPluginWithParcelParams}.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function buildObsidianPluginWithParcel(params: BuildObsidianPluginWithParcelParams): Promise<CliTaskResult> {\n  await npmRunOptional('build:compile');\n  const buildContext = await resolveObsidianPluginBuildContext(params);\n  await cleanObsidianPluginDistFolder(buildContext.distFolder);\n  await completeObsidianPluginDistFolder(buildContext);\n\n  const configFolder = resolveFromRoot(GENERATED_PARCEL_CONFIG_FOLDER);\n  const consumerParcelrcPath = resolveFromRoot(PARCELRC);\n  await mkdir(configFolder, { recursive: true });\n  const configFiles = getParcelConfigFiles({\n    consumerParcelrcPath: existsSync(consumerParcelrcPath) ? toPosixPath(relative(configFolder, consumerParcelrcPath)) : undefined,\n    features: params\n  });\n  for (const [fileName, contents] of Object.entries(configFiles)) {\n    const filePath = join(configFolder, fileName);\n    // Rewritten only when it changed: parcel invalidates its cache on a config file's modification time.\n    if (!existsSync(filePath) || await readFile(filePath, 'utf-8') !== contents) {\n      await writeFile(filePath, contents, 'utf-8');\n    }\n  }\n\n  const { Parcel } = await import('@parcel/core');\n  const parcelOptions = getParcelOptions({ buildContext, cacheFolder: resolveFromRoot(PARCEL_CACHE_FOLDER), configPath: join(configFolder, PARCELRC) });\n  const bundler = new Parcel(params.customizeParcelOptions?.(parcelOptions) ?? parcelOptions);\n\n  if (buildContext.isProductionBuild) {\n    try {\n      const { buildTime, bundleGraph } = await bundler.run();\n      console.warn(`Built ${String(bundleGraph.getBundles().length)} bundle(s) with parcel in ${String(buildTime)} ms.`);\n      return CliTaskResult.Success();\n    } catch (error) {\n      console.error(formatParcelError(error));\n      return CliTaskResult.Failure();\n    }\n  }\n\n  await bundler.watch((error, event) => {\n    if (error) {\n      console.error(formatParcelError(error));\n      return;\n    }\n    handleWatchEvent(event, buildContext);\n  });\n  return CliTaskResult.DoNotExit();\n}\n\n/**\n * Builds the Obsidian plugin in development mode using parcel, watching for changes and deploying every\n * successful rebuild into the vault.\n *\n * @param options - Optional build options.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the build result.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares BuildOptions with build().\nexport async function dev(options?: BuildOptions): Promise<CliTaskResult> {\n  return await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Development });\n}\n/* v8 ignore stop */\n\n/**\n * Generates the files of the parcel configuration the build runs with.\n *\n * The build features add pipelines that run the toolkit's shared transforms, through one generated transformer that\n * loads them from the toolkit: Solid's `.jsx` / `.tsx`, Svelte's `.svelte` / `.svelte.ts` / `.svelte.js`, `.wasm`,\n * and with `styles.postcss` or `styles.tailwind` every stylesheet, in place of parcel's own PostCSS step. React and\n * Preact JSX is compiled here too, since parcel reads the JSX runtime from a tsconfig without following its `extends`,\n * and with any framework every script has the framework's compile-time constants replaced. Parcel compiles Vue with\n * `@parcel/transformer-vue` and scopes `*.module.css` itself, so those need no pipeline here.\n *\n * @param params - The {@link GetParcelConfigFilesParams}.\n * @returns The files, by file name.\n */\nexport function getParcelConfigFiles(params: GetParcelConfigFilesParams): ParcelConfigFiles {\n  const { consumerParcelrcPath, features = {} } = params;\n  const featureTransformer = `./${FEATURES_FILE_NAME}`;\n  const transformers: Record<string, string[]> = {};\n  if (features.framework === 'svelte') {\n    transformers['*.svelte'] = [featureTransformer];\n    transformers['*.svelte.{js,ts}'] = [featureTransformer, `./${INLINE_IMPORTS_FILE_NAME}`, '...'];\n  }\n  if (features.framework === 'solid' || getJsxImportSource(features.framework) !== undefined) {\n    transformers['*.{jsx,tsx}'] = [featureTransformer];\n  }\n  if (features.wasm) {\n    transformers['*.wasm'] = [featureTransformer];\n  }\n  if (isPostcssNeeded(features.styles)) {\n    transformers['*.{css,pcss}'] = [featureTransformer, '@parcel/transformer-css'];\n  }\n  const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild: true });\n  transformers['*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'] = [\n    ...Object.keys(defines).length > 0 ? [featureTransformer] : [],\n    `./${INLINE_IMPORTS_FILE_NAME}`,\n    '...'\n  ];\n\n  const parcelrc = {\n    extends: consumerParcelrcPath ?? '@parcel/config-default',\n    namers: [`./${NAMER_FILE_NAME}`, '...'],\n    optimizers: {\n      '*.js': [`./${PRE_MINIFY_FILE_NAME}`, '...', `./${OPTIMIZER_FILE_NAME}`]\n    },\n    resolvers: [`./${RESOLVER_FILE_NAME}`, '...'],\n    transformers\n  };\n\n  return {\n    [FEATURES_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs the toolkit's shared transforms for the build features, loaded\n * from the toolkit itself, so parcel compiles each feature the way every other bundler adapter does.\n */\nconst { Transformer } = require('@parcel/plugin');\n\nconst FEATURES_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl('obsidian-plugin-features'))};\nconst TRANSFORMS_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl('obsidian-plugin-transforms'))};\nconst FRAMEWORK = ${JSON.stringify(features.framework ?? null)};\nconst STYLES = ${JSON.stringify(features.styles ?? {})};\n\nmodule.exports = new Transformer({\n  async transform({ asset, options }) {\n    const { getFeatureFileKind, getFrameworkDefines, getJsxImportSource, replaceDefines } = await import(FEATURES_MODULE_URL);\n    const transforms = await import(TRANSFORMS_MODULE_URL);\n    const filePath = asset.filePath;\n    const isProductionBuild = options.mode === 'production';\n    const defines = getFrameworkDefines({ framework: FRAMEWORK ?? undefined, isProductionBuild });\n    switch (getFeatureFileKind(filePath)) {\n      case 'jsx': {\n        const code = await asset.getCode();\n        const jsxImportSource = getJsxImportSource(FRAMEWORK ?? undefined);\n        const result = FRAMEWORK === 'solid'\n          ? await transforms.transformSolid({ code, filePath, isProductionBuild })\n          : await transforms.transformJsx({ code, filePath, isProductionBuild, jsxImportSource });\n        asset.setCode(replaceDefines(result.code, defines));\n        asset.type = 'js';\n        break;\n      }\n      case 'stylesheet': {\n        const result = await transforms.transformCss({ filePath, isCssModuleScoped: false, isProductionBuild, source: await asset.getCode(), styles: STYLES });\n        asset.setCode(result.css);\n        for (const dependency of result.dependencies) {\n          asset.invalidateOnFileChange(dependency);\n        }\n        break;\n      }\n      case 'svelte': {\n        const result = await transforms.transformSvelte({ code: await asset.getCode(), filePath, isProductionBuild });\n        asset.setCode(replaceDefines(result.code, defines));\n        asset.type = 'js';\n        break;\n      }\n      case 'wasm':\n        asset.setCode(transforms.getWasmModuleCode(await asset.getBuffer()));\n        asset.type = 'js';\n        break;\n      default: {\n        // A framework's runtime reads process.env.NODE_ENV, which parcel leaves alone in an electron-renderer library.\n        const code = await asset.getCode();\n        const replaced = replaceDefines(code, defines);\n        if (replaced !== code) {\n          asset.setCode(replaced);\n        }\n        break;\n      }\n    }\n    return [asset];\n  }\n});\n`,\n    // `String.raw`, so the regular expression below reaches the file with its backslashes intact.\n    [INLINE_IMPORTS_FILE_NAME]: String.raw`/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Keeps every dynamic import() inside main.js.\n *\n * Obsidian loads a plugin's main.js and nothing beside it, and parcel makes every import() a bundle of its\n * own with no option to inline one. This rewrites import('<literal>') into a require() inside an async\n * arrow, before parcel's own JavaScript transformer runs: the module still evaluates only when that code\n * runs, and the promise still rejects when evaluation throws. Only a plain string specifier is rewritten,\n * since a computed one cannot be bundled by any bundler.\n */\nconst { Transformer } = require('@parcel/plugin');\n\nconst DYNAMIC_IMPORT = /\\bimport\\(\\s*([\"'])([^\"'\\x60\\n\\\\]+)\\1\\s*\\)/gu;\n\nmodule.exports = new Transformer({\n  async transform({ asset }) {\n    const source = await asset.getCode();\n    if (source.includes('import(')) {\n      asset.setCode(source.replace(DYNAMIC_IMPORT, (_match, quote, specifier) => '(async () => require(' + quote + specifier + quote + '))()'));\n    }\n    return [asset];\n  }\n});\n`,\n    [NAMER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Obsidian loads a plugin's stylesheet from styles.css and nothing else. */\nconst { Namer } = require('@parcel/plugin');\n\nmodule.exports = new Namer({\n  name({ bundle }) {\n    return bundle.type === 'css' ? '${ObsidianPluginRepoPaths.StylesCss}' : null;\n  }\n});\n`,\n    [OPTIMIZER_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs after parcel's own optimizers, on the JavaScript bundle.\n *\n * Obsidian evaluates main.js as the body of function (require, module, exports), with a module object that\n * has no require of its own, and parcel's runtime reaches every external module through module.require.\n * Without the first line below, the very first require('obsidian') throws \"Cannot find module\". The banner\n * goes in here too, after minification, which would otherwise strip it as an ordinary comment.\n */\nconst { Optimizer } = require('@parcel/plugin');\n\nconst PREAMBLE = ${JSON.stringify(`${getObsidianPluginBanner('parcel')}if (typeof module === 'object' && typeof module.require !== 'function') { module.require = require; }\\n`)};\nconst PREAMBLE_LINE_COUNT = ${String(getObsidianPluginBanner('parcel').split('\\n').length)};\n\nasync function readContents(contents) {\n  if (typeof contents === 'string') {\n    return contents;\n  }\n  if (Buffer.isBuffer(contents)) {\n    return contents.toString('utf-8');\n  }\n  const chunks = [];\n  for await (const chunk of contents) {\n    chunks.push(Buffer.from(chunk));\n  }\n  return Buffer.concat(chunks).toString('utf-8');\n}\n\nmodule.exports = new Optimizer({\n  async optimize({ contents, map }) {\n    const code = await readContents(contents);\n    if (map) {\n      map.offsetLines(1, PREAMBLE_LINE_COUNT);\n    }\n    return { contents: PREAMBLE + code, map };\n  }\n});\n`,\n    [PARCELRC]: `${JSON.stringify(parcelrc, null, JSON_INDENT)}\\n`,\n    // `String.raw`, so the line breaks below reach the file as escapes.\n    [PRE_MINIFY_FILE_NAME]: String.raw`/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs before parcel's own optimizers, on the JavaScript bundle.\n *\n * A scope-hoisted library bundle require()s every bundle it references, the stylesheet included, and Obsidian\n * loads styles.css itself, beside main.js, where a require() cannot reach it. The line is blanked rather than\n * removed, so a source map still lines up.\n *\n * A scope-hoisted CommonJS bundle also declares every module's bindings at its top level, under long names such\n * as $c5899aeb4caadf27$var$taskIdCounter, and parcel minifies it as a script, where the minifier may not rename\n * a top-level binding, since in a script it is a global. Obsidian evaluates main.js as the body of a function, so\n * wrapping the bundle in an arrow function changes nothing at runtime (an arrow keeps this and arguments) and\n * lets the minifier rename all of them: Solid's fixture build is 70 KB without this and 10 KB with it.\n */\nconst { Optimizer } = require('@parcel/plugin');\n\nconst STYLESHEET_REQUIRE = ${JSON.stringify(`require(\"./${ObsidianPluginRepoPaths.StylesCss}\");\\n`)};\n\nasync function readContents(contents) {\n  if (typeof contents === 'string') {\n    return contents;\n  }\n  if (Buffer.isBuffer(contents)) {\n    return contents.toString('utf-8');\n  }\n  const chunks = [];\n  for await (const chunk of contents) {\n    chunks.push(Buffer.from(chunk));\n  }\n  return Buffer.concat(chunks).toString('utf-8');\n}\n\nmodule.exports = new Optimizer({\n  async optimize({ bundle, contents, map }) {\n    const code = (await readContents(contents)).replace(STYLESHEET_REQUIRE, '\\n');\n    if (!bundle.env.shouldOptimize) {\n      return { contents: code, map };\n    }\n    if (map) {\n      map.offsetLines(1, 1);\n    }\n    return { contents: '(() => {\\n' + code + '\\n})();\\n', map };\n  }\n});\n`,\n    [RESOLVER_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Leaves the modules Obsidian supplies at runtime to require(), and\n * resolves everything else the way @parcel/resolver-default does, with the browser's export conditions.\n *\n * Parcel resolves an electron-renderer target with the node and electron conditions beside browser, and an exports\n * map is matched in the package's own key order, so a package listing node first (Vue, Svelte, Solid, fflate) would\n * hand over its Node build: several times the code, and one that may not load on mobile. The Node builtins need no\n * node condition to stay external, since they are in the externals below.\n */\nconst { Resolver } = require('@parcel/plugin');\nconst { dirname } = require('node:path');\n\nconst EXTERNALS = new Set(${JSON.stringify(OBSIDIAN_PLUGIN_EXTERNALS)});\n\nfunction getBrowserEnvironment(env) {\n  return {\n    context: env.context,\n    id: env.id + ':obsidian-dev-toolkit-browser-conditions',\n    includeNodeModules: env.includeNodeModules,\n    isBrowser: () => true,\n    isElectron: () => false,\n    isLibrary: env.isLibrary,\n    isNode: () => false,\n    isWorker: () => env.isWorker(),\n    isWorklet: () => env.isWorklet()\n  };\n}\n\nfunction getPackageName(specifier) {\n  const segments = specifier.split('/');\n  return specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];\n}\n\n// @parcel/node-resolver-core is what @parcel/resolver-default runs, reached through the packages that install it.\nfunction loadNodeResolver() {\n  let folder = __dirname;\n  for (const packageName of ['@parcel/config-default', '@parcel/resolver-default']) {\n    folder = dirname(require.resolve(packageName + '/package.json', { paths: [folder] }));\n  }\n  return require(require.resolve('@parcel/node-resolver-core', { paths: [folder] })).default;\n}\n\nmodule.exports = new Resolver({\n  async loadConfig({ config, logger, options }) {\n    const packageConfig = await config.getConfig([], { packageKey: '@parcel/resolver-default' });\n    const NodeResolver = loadNodeResolver();\n    return new NodeResolver({\n      fs: options.inputFS,\n      logger,\n      mode: options.mode,\n      packageExports: packageConfig?.contents?.packageExports ?? false,\n      packageManager: options.packageManager,\n      projectRoot: options.projectRoot,\n      shouldAutoInstall: options.shouldAutoInstall\n    });\n  },\n  resolve({ config: nodeResolver, dependency, specifier }) {\n    const isExternal = specifier.startsWith('node:') || EXTERNALS.has(specifier) || EXTERNALS.has(getPackageName(specifier));\n    if (isExternal) {\n      return { isExcluded: true };\n    }\n    return nodeResolver.resolve({\n      env: getBrowserEnvironment(dependency.env),\n      filename: specifier,\n      loc: dependency.loc,\n      packageConditions: dependency.packageConditions,\n      parent: dependency.resolveFrom,\n      range: dependency.range,\n      sourcePath: dependency.sourcePath,\n      specifierType: dependency.specifierType\n    });\n  }\n});\n`\n  };\n}\n\n/**\n * Builds the options handed to parcel's `Parcel` class.\n *\n * The one target is `electron-renderer`, where Obsidian runs a plugin, and CommonJS. Parcel counts that\n * context as both a browser and a node one: node keeps `process`, `Buffer` and `process.env` as Obsidian's\n * renderer has them, rather than polyfilled or inlined from the build machine, and browser takes a package's\n * `browser` field. Its export conditions would include `node` too, which the generated resolver drops.\n * `includeNodeModules` bundles the dependencies, which a node-flavoured context would otherwise leave as\n * `require()` calls nothing installs beside a plugin, and `isLibrary` keeps the entry's default export, which\n * is how Obsidian finds the plugin class.\n *\n * `shouldScopeHoist` is set explicitly because parcel reads it only from `defaultTargetOptions` for a target\n * passed in the options, never from `isLibrary` as it does for one in `package.json`. Without it the bundle\n * is not tree-shaken at all: Svelte's fixture build was 224 KB with parcel against 25 KB with vite.\n *\n * @param params - The {@link GetParcelOptionsParams}.\n * @returns The parcel options.\n */\nexport function getParcelOptions(params: GetParcelOptionsParams): InitialParcelOptions {\n  const { buildContext, cacheFolder, configPath } = params;\n  const target: TargetDescriptor = {\n    context: 'electron-renderer',\n    // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.\n    distDir: buildContext.distFolder,\n    includeNodeModules: true,\n    isLibrary: true,\n    optimize: buildContext.isProductionBuild,\n    outputFormat: 'commonjs',\n    sourceMap: !buildContext.isProductionBuild && { inline: true }\n  };\n\n  return {\n    // eslint-disable-next-line unicorn/name-replacements -- `cacheDir` is the name parcel's API reads.\n    cacheDir: cacheFolder,\n    config: configPath,\n    defaultTargetOptions: {\n      // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.\n      distDir: buildContext.distFolder,\n      shouldOptimize: buildContext.isProductionBuild,\n      shouldScopeHoist: true,\n      sourceMaps: !buildContext.isProductionBuild\n    },\n    entries: buildContext.entryPoint,\n    mode: buildContext.isProductionBuild ? 'production' : 'development',\n    targets: { obsidianPlugin: target }\n  };\n}\n/* v8 ignore start -- Part of the parcel build above. */\nfunction formatParcelError(error: unknown): string {\n  const diagnostics = (error as ParcelErrorLike | undefined)?.diagnostics;\n  if (diagnostics && diagnostics.length > 0) {\n    return diagnostics.map((diagnostic) => diagnostic.message).join('\\n');\n  }\n  return error instanceof Error ? error.stack ?? error.message : String(error);\n}\n\n/**\n * Builds the URL of a module of this folder, in the same form as this one (`.ts` from source, `.mjs` or `.cjs` once\n * built), which the generated transformer imports.\n *\n * @param baseName - The module's file name without its extension.\n * @returns The module's `file:` URL.\n */\nfunction getSiblingModuleUrl(baseName: string): string {\n  return new URL(`${baseName}${extname(new URL(import.meta.url).pathname)}`, import.meta.url).href;\n}\n\nfunction handleWatchEvent(event: BuildEvent | undefined, buildContext: ObsidianPluginBuildContext): void {\n  if (event?.type === 'buildFailure') {\n    console.error(event.diagnostics.map((diagnostic) => diagnostic.message).join('\\n'));\n    return;\n  }\n  if (event?.type !== 'buildSuccess') {\n    return;\n  }\n\n  console.warn(`Rebuilt with parcel in ${String(event.buildTime)} ms.`);\n  invokeAsyncSafely(() => deployToObsidianPluginsFolder(buildContext));\n}\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}