@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/library-build.d.mts

@@ -0,0 +1,97 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * The build pipeline of a TypeScript LIBRARY package: one `dist/lib/{cjs,esm}` tree of unbundled modules beside its
+ * `.d.cts` / `.d.mts` declarations, the generated `index.ts` barrels, and the generated `package.json` `exports` map.
+ *
+ * Each step works on the current working folder, which is the package being built. A repository's
+ * `scripts/build-*.ts` entry points are thin `wrapCliTask` wrappers around these functions, and its `build` script
+ * runs them in order through {@link runBuildSteps}.
+ */
+import type { Plugin } from 'esbuild';
+/**
+ * The banner every emitted library module opens with.
+ */
+export declare const LIBRARY_BANNER = "/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n";
+/**
+ * The steps of a library build, in the order {@link runBuildSteps} runs them.
+ */
+export declare const LIBRARY_BUILD_STEPS: readonly string[];
+/**
+ * The export condition the `obsidian-dev-utils` workspace maps every subpath onto its TypeScript source with, so a
+ * package there can import a sibling package's source before anything is built. Pass it to
+ * {@link generateLibraryExports} through {@link GenerateLibraryExportsOptions.sourceCondition}.
+ */
+export declare const SOURCE_CONDITION = "@mnaoumov/source";
+/**
+ * Options for {@link buildLibrary}.
+ */
+export interface BuildLibraryOptions {
+    /**
+     * Creates the preprocess plugin for one output format. Defaults to the generic one, which carries no
+     * environment-specific `require` patch.
+     */
+    readonly preprocessPluginFactory?: (isEsm: boolean) => Plugin;
+}
+/**
+ * Options for {@link generateLibraryExports}.
+ */
+export interface GenerateLibraryExportsOptions {
+    /**
+     * An export condition to put first in every entry, mapping the subpath onto its TypeScript source. Only a
+     * repository holding several packages that import each other needs one; nothing outside it sets the condition, and
+     * the sources it points at do not ship, so the publish has to strip it again. Omitted, the map has none.
+     */
+    readonly sourceCondition?: string | undefined;
+}
+/**
+ * Removes everything an earlier build left: `dist/`, the generated `index.ts` barrels, the `.d.ts` files `tsc` wrote
+ * beside the sources (hand-authored ones under `@types` stay), and the per-subpath `package.json` stubs.
+ *
+ * @returns A {@link Promise} that resolves when everything has been removed.
+ */
+export declare function buildCleanLibrary(): Promise<void>;
+/**
+ * Builds every source module, unbundled, into `dist/lib/cjs` (`.cjs`) and `dist/lib/esm` (`.mjs`).
+ *
+ * The output folders must already exist; {@link buildLibraryTypes} creates them.
+ *
+ * @param options - The build options.
+ * @returns A {@link Promise} that resolves when both formats have been built.
+ */
+export declare function buildLibrary(options?: BuildLibraryOptions): Promise<void>;
+/**
+ * Emits the declarations with `tsc --project ./tsconfig.types.json`, then copies each one into `dist/lib` twice: as a
+ * `.d.cts` whose relative imports name `.cjs` files and whose bare type imports carry `resolution-mode: import`, and
+ * as a `.d.mts` whose relative imports name `.mjs` files.
+ *
+ * The library's root declaration (`library.ts` where the package has one, otherwise the generated `index.ts`) carries
+ * every `lib` and `types` reference the package needs; every other declaration references it by path.
+ *
+ * @returns A {@link Promise} that resolves when the declarations have been written.
+ */
+export declare function buildLibraryTypes(): Promise<void>;
+/**
+ * Regenerates the `exports` map of the package's `package.json` from its source folders, and writes a `package.json`
+ * stub per subpath for resolvers that do not read `exports`.
+ *
+ * @param options - The {@link GenerateLibraryExportsOptions}.
+ * @returns A {@link Promise} that resolves when the map is current.
+ * @throws If the map changed, so the change gets reviewed and committed rather than shipped unseen.
+ */
+export declare function generateLibraryExports(options?: GenerateLibraryExportsOptions): Promise<void>;
+/**
+ * Generates an `index.ts` barrel in every source folder that has something to export, re-exporting each module and
+ * each sub-barrel under its own name.
+ *
+ * @returns A {@link Promise} that resolves when the barrels have been written.
+ */
+export declare function generateLibraryIndex(): Promise<void>;
+/**
+ * Runs each named npm script the package defines, in order, skipping the ones it does not define.
+ *
+ * @param steps - The npm script names.
+ * @returns A {@link Promise} that resolves when every step has run.
+ */
+export declare function runBuildSteps(steps?: readonly string[]): Promise<void>;

package/dist/lib/esm/library-build.mjs

@@ -0,0 +1,435 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { asyncMap } from "@mnaoumov/typescript-lib/async";
+import { isDeepEqual } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  basename,
+  dirname,
+  extname,
+  join,
+  normalizeIfRelative,
+  relative
+} from "@mnaoumov/typescript-lib/path";
+import { replaceAll } from "@mnaoumov/typescript-lib/string";
+import { context } from "esbuild";
+import {
+  existsSync,
+  readFileSync
+} from "node:fs";
+import {
+  mkdir,
+  readFile,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { relative as relativeNative } from "node:path";
+import process from "node:process";
+import { buildClean } from "./build.mjs";
+import { changeExtensionPlugin } from "./bundlers/esbuild-impl/change-extension-plugin.mjs";
+import { fixEsmPlugin } from "./bundlers/esbuild-impl/fix-esm-plugin.mjs";
+import { preprocessPlugin } from "./bundlers/esbuild-impl/preprocess-plugin.mjs";
+import { parseTsConfig } from "./check-project-types.mjs";
+import { generate } from "./code-generator.mjs";
+import { readdirPosix } from "./fs.mjs";
+import { writeJson } from "./json.mjs";
+import { npmRunOptional } from "./npm-run.mjs";
+import { editPackageJson } from "./npm.mjs";
+import { resolveToolCommand } from "./package-manager.mjs";
+import { RepoPaths } from "./repo-paths.mjs";
+import { execFromRoot } from "./root.mjs";
+const LIBRARY_BANNER = `/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+`;
+const LIBRARY_BUILD_STEPS = [
+  "build:clean",
+  "build:generate-index",
+  "build:compile",
+  "build:types",
+  "build:validate-declarations",
+  "build:lib",
+  "build:generate-exports"
+];
+const SOURCE_CONDITION = "@mnaoumov/source";
+const DECLARATION_REFERENCE_TYPES = /* @__PURE__ */ new Set(["node"]);
+const REFERENCE_LIB_DIRECTIVE = ["<reference", "lib="].join(" ");
+const REFERENCE_LIB_REG_EXP = /\/\/\/ <reference lib="(?<Lib>[^"]+)" \/>/gm;
+const BARE_TYPE_IMPORT_REG_EXP = /^import type (?<Clause>.+?) from '(?<Specifier>[^.'][^']*)';$/gm;
+const BARE_INLINE_IMPORT_TYPE_REG_EXP = /import\("(?<Specifier>[^."][^"]*)"\)/g;
+const STATIC_IMPORT_REG_EXP = /from '(?<ImportPath>.+?)\.ts';/gm;
+const DYNAMIC_IMPORT_REG_EXP = /import\((?<Quote>['"])(?<ImportPath>.+?)\.ts\k<Quote>\)/gm;
+async function buildCleanLibrary() {
+  await buildClean();
+  for (const file of await readdirPosix(RepoPaths.Src, { recursive: true })) {
+    if (basename(file) === RepoPaths.IndexTs) {
+      await rm(join(RepoPaths.Src, file));
+    }
+    if (file.endsWith(RepoPaths.DtsExtension) && !file.split("/").includes(RepoPaths.Types)) {
+      await rm(join(RepoPaths.Src, file));
+    }
+  }
+  for (const file of await readdirPosix(RepoPaths.CurrentFolder, { recursive: true })) {
+    if (basename(file) !== RepoPaths.PackageJson || file === RepoPaths.PackageJson || file.startsWith(RepoPaths.NodeModules)) {
+      continue;
+    }
+    await rm(file);
+  }
+}
+async function buildLibrary(options = {}) {
+  const { preprocessPluginFactory = (isEsm) => preprocessPlugin({ isEsm }) } = options;
+  const libFiles = await getLibFiles();
+  await buildLibraryFormat({ format: "cjs", libFiles, preprocessPluginFactory });
+  await buildLibraryFormat({ format: "esm", libFiles, preprocessPluginFactory });
+}
+async function buildLibraryTypes() {
+  await execFromRoot([...resolveToolCommand({ tool: "tsc" }), "--project", "./tsconfig.types.json"]);
+  const libraryFileName = existsSync(join(RepoPaths.Src, "library.ts")) ? "library" : "index";
+  const allLibs = await collectAllLibs();
+  const allTypes = collectAllTypes();
+  for (const file of await readdirPosix(RepoPaths.Src, { recursive: true })) {
+    if (!file.endsWith(RepoPaths.DtsExtension) || file.startsWith(RepoPaths.TestHelpers)) {
+      continue;
+    }
+    const folder = dirname(file);
+    const name = basename(file, RepoPaths.DtsExtension);
+    const content = await readFile(join(RepoPaths.Src, file), "utf-8");
+    const ctsPath = join(RepoPaths.DistLib, RepoPaths.Cjs, folder, name + RepoPaths.DctsExtension);
+    const mtsPath = join(RepoPaths.DistLib, RepoPaths.Esm, folder, name + RepoPaths.DmtsExtension);
+    await mkdir(dirname(ctsPath), { recursive: true });
+    await mkdir(dirname(mtsPath), { recursive: true });
+    let ctsContent = toCtsContent(content);
+    let mtsContent = toMtsContent(content);
+    if (name === libraryFileName && folder === ".") {
+      const directives = buildAllReferenceLibDirectives(allLibs) + buildAllReferenceTypesDirectives(allTypes);
+      ctsContent = directives + ctsContent;
+      mtsContent = directives + mtsContent;
+    } else {
+      ctsContent = buildReferencePathDirective({ declarationFilePath: ctsPath, extension: RepoPaths.DctsExtension, libraryFileName, moduleDirectory: RepoPaths.Cjs }) + ctsContent;
+      mtsContent = buildReferencePathDirective({ declarationFilePath: mtsPath, extension: RepoPaths.DmtsExtension, libraryFileName, moduleDirectory: RepoPaths.Esm }) + mtsContent;
+    }
+    await writeFile(ctsPath, ctsContent);
+    await writeFile(mtsPath, mtsContent);
+  }
+}
+async function generateLibraryExports(options = {}) {
+  const { sourceCondition } = options;
+  const srcFolders = [RepoPaths.Src];
+  for (const dirent of await readdirPosix(RepoPaths.Src, { recursive: true, withFileTypes: true })) {
+    if (!dirent.isDirectory()) {
+      continue;
+    }
+    const path = join(dirent.parentPath, dirent.name);
+    if (path.includes(RepoPaths.Styles) || path.includes(RepoPaths.TestHelpers)) {
+      continue;
+    }
+    srcFolders.push(path);
+  }
+  srcFolders.sort();
+  let isChanged = false;
+  await editPackageJson(async (packageJson) => {
+    const oldExports = packageJson.exports;
+    const exportConditions = {};
+    packageJson.exports = exportConditions;
+    for (const srcFolder of srcFolders) {
+      await setExport({ exportConditions, isWildcard: false, sourceCondition, srcFolder });
+      await setExport({ exportConditions, isWildcard: true, sourceCondition, srcFolder });
+    }
+    isChanged = !isDeepEqual(oldExports, packageJson.exports);
+  });
+  if (isChanged) {
+    throw new Error("Package exports have changed. Please review the changes and commit them.");
+  }
+}
+async function generateLibraryIndex() {
+  await generateIndex(RepoPaths.Src);
+}
+async function runBuildSteps(steps = LIBRARY_BUILD_STEPS) {
+  for (const step of steps) {
+    await npmRunOptional(step);
+  }
+}
+function buildAllReferenceLibDirectives(libs) {
+  return `${libs.map((lib) => `/// ${REFERENCE_LIB_DIRECTIVE}"${lib}" />`).join("\n")}
+`;
+}
+function buildAllReferenceTypesDirectives(types) {
+  return types.length === 0 ? "" : `${types.map((type) => `/// <reference types="${type}" />`).join("\n")}
+`;
+}
+async function buildLibraryFormat(params) {
+  const { format, libFiles, preprocessPluginFactory } = params;
+  const extension = format === "cjs" ? RepoPaths.CjsExtension : RepoPaths.MjsExtension;
+  const buildOptions = {
+    // Explicit, because esbuild otherwise takes the folder its service process started in.
+    // eslint-disable-next-line unicorn/name-replacements -- esbuild's own option name.
+    absWorkingDir: process.cwd(),
+    banner: {
+      js: LIBRARY_BANNER
+    },
+    bundle: false,
+    entryPoints: libFiles,
+    format,
+    logLevel: "info",
+    outdir: join(RepoPaths.DistLib, format),
+    platform: "node",
+    plugins: [
+      preprocessPluginFactory(format === "esm"),
+      fixEsmPlugin(),
+      changeExtensionPlugin(extension)
+    ],
+    sourcemap: "inline",
+    target: "ES2022",
+    treeShaking: true,
+    write: false
+  };
+  const buildContext = await context(buildOptions);
+  try {
+    await buildContext.rebuild();
+  } finally {
+    await buildContext.dispose();
+  }
+}
+function buildReferencePathDirective(params) {
+  const { declarationFilePath, extension, libraryFileName, moduleDirectory } = params;
+  const libraryFilePath = join(RepoPaths.DistLib, moduleDirectory, libraryFileName + extension);
+  let relativePath = relativeNative(dirname(declarationFilePath), libraryFilePath).replaceAll("\\", "/");
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+  return `/// <reference path="${relativePath}" />
+`;
+}
+async function collectAllLibs() {
+  const { options } = parseTsConfig(RepoPaths.TsConfigJson);
+  const libs = new Set((options.lib ?? []).map((lib) => lib.toLowerCase().replace(/^lib\./, "").replace(/\.d\.ts$/, "")));
+  for (const file of await readdirPosix(RepoPaths.Src, { recursive: true })) {
+    if (!file.endsWith(".ts")) {
+      continue;
+    }
+    const sourceContent = readFileSync(join(RepoPaths.Src, file), "utf-8");
+    for (const [, lib] of sourceContent.matchAll(REFERENCE_LIB_REG_EXP)) {
+      libs.add(String(lib).toLowerCase());
+    }
+  }
+  return [...libs].sort();
+}
+function collectAllTypes() {
+  const { options } = parseTsConfig(RepoPaths.TsConfigJson);
+  return (options.types ?? []).filter((type) => DECLARATION_REFERENCE_TYPES.has(type)).sort();
+}
+async function generateIndex(folder) {
+  const dirents = await readdirPosix(folder, { withFileTypes: true });
+  const maybeLines = await asyncMap(dirents, (dirent) => handleIndexDirent(folder, dirent));
+  const lines = maybeLines.filter((line) => line !== void 0);
+  if (lines.length === 0) {
+    return "skipped" /* Skipped */;
+  }
+  await generate(join(folder, RepoPaths.IndexTs), lines);
+  return "success" /* Success */;
+}
+async function getLibFiles() {
+  let files = await readdirPosix(RepoPaths.Src, { recursive: true });
+  files = files.map((file) => normalizeIfRelative(join(RepoPaths.Src, file)));
+  return files.filter(
+    (file) => file.endsWith(RepoPaths.TsExtension) && !file.endsWith(RepoPaths.DtsExtension) && !file.endsWith(".test.ts") && !file.includes(`/${RepoPaths.TestHelpers}/`)
+  );
+}
+async function handleIndexDirent(folder, dirent) {
+  if (isExcludedFromIndex(folder, dirent)) {
+    return;
+  }
+  let sourceFile;
+  let name;
+  if (dirent.isDirectory()) {
+    const result = await generateIndex(join(folder, dirent.name));
+    if (result !== "success" /* Success */) {
+      return;
+    }
+    sourceFile = normalizeIfRelative(join(dirent.name, RepoPaths.IndexTs));
+    name = dirent.name;
+  } else {
+    const extension = extname(dirent.name);
+    name = basename(dirent.name, extension);
+    sourceFile = normalizeIfRelative(dirent.name);
+  }
+  return `export * as '${name}' from '${sourceFile}';`;
+}
+function isExcludedFileName(name) {
+  return !name.endsWith(RepoPaths.TsExtension) || name.endsWith(".test.ts") || name === "setup.ts" || name.endsWith("-setup.ts");
+}
+function isExcludedFromIndex(folder, dirent) {
+  const excludedNames = [RepoPaths.IndexTs, RepoPaths.Types, RepoPaths.Styles, RepoPaths.TestHelpers];
+  const isExcludedEntry = excludedNames.includes(dirent.name) || dirent.name.endsWith(RepoPaths.DtsExtension) || folder.split("/").includes(RepoPaths.Types);
+  return isExcludedEntry || dirent.isFile() && isExcludedFileName(dirent.name);
+}
+async function setExport(params) {
+  const { exportConditions, isWildcard, sourceCondition, srcFolder } = params;
+  const importPath = replaceAll({
+    $string: srcFolder,
+    replacer: RepoPaths.CurrentFolder,
+    searchValue: RepoPaths.Src
+  });
+  const conditionPath = isWildcard ? `${importPath}/${RepoPaths.Any}` : importPath;
+  const dmtsPath = toDistPath({ format: RepoPaths.Esm, importPath, name: isWildcard ? RepoPaths.AnyDmts : RepoPaths.IndexDmts });
+  const dctsPath = toDistPath({ format: RepoPaths.Cjs, importPath, name: isWildcard ? RepoPaths.AnyDcts : RepoPaths.IndexDcts });
+  const dmtsFolderPath = dirname(dmtsPath);
+  const dctsFolderPath = dirname(dctsPath);
+  if (!isWildcard && !existsSync(dctsPath)) {
+    return;
+  }
+  const isTypesOnly = importPath.includes(RepoPaths.Types);
+  const mjsPath = toDistPath({ format: RepoPaths.Esm, importPath, name: isWildcard ? RepoPaths.AnyMjs : RepoPaths.IndexMjs });
+  const cjsPath = toDistPath({ format: RepoPaths.Cjs, importPath, name: isWildcard ? RepoPaths.AnyCjs : RepoPaths.IndexCjs });
+  if (isTypesOnly) {
+    exportConditions[conditionPath] = {
+      import: {
+        types: dmtsPath
+      },
+      require: {
+        types: dctsPath
+      }
+    };
+  } else {
+    const sourcePath = normalizeIfRelative(join(RepoPaths.Src, importPath, isWildcard ? RepoPaths.AnyTs : RepoPaths.IndexTs));
+    exportConditions[conditionPath] = {
+      /* eslint-disable perfectionist/sort-objects -- Order matters once it is written to `package.json`. */
+      // First, so it wins wherever it is set: inside the repository, before anything is built.
+      ...sourceCondition !== void 0 && { [sourceCondition]: sourcePath },
+      import: {
+        types: dmtsPath,
+        default: mjsPath
+      },
+      require: {
+        types: dctsPath,
+        default: cjsPath
+      }
+      /* eslint-enable perfectionist/sort-objects -- Order matters once it is written to `package.json`. */
+    };
+  }
+  if (importPath === RepoPaths.CurrentFolder) {
+    return;
+  }
+  if (!isWildcard) {
+    await writeSubpathPackageJson(
+      importPath,
+      isTypesOnly ? { type: "module", types: relative(importPath, dctsPath) } : { main: relative(importPath, cjsPath), module: relative(importPath, mjsPath), type: "module", types: relative(importPath, dctsPath) }
+    );
+    return;
+  }
+  for (const file of await readdirPosix(dctsFolderPath)) {
+    if (!file.endsWith(RepoPaths.DctsExtension)) {
+      continue;
+    }
+    const name = basename(file, RepoPaths.DctsExtension);
+    const packageJsonFolderPath = join(importPath, name);
+    const types = relative(packageJsonFolderPath, join(dctsFolderPath, name + RepoPaths.DctsExtension));
+    await writeSubpathPackageJson(
+      packageJsonFolderPath,
+      isTypesOnly ? { type: "module", types } : {
+        main: relative(packageJsonFolderPath, join(dctsFolderPath, name + RepoPaths.CjsExtension)),
+        module: relative(packageJsonFolderPath, join(dmtsFolderPath, name + RepoPaths.MjsExtension)),
+        type: "module",
+        types
+      }
+    );
+  }
+}
+function toCtsContent(content) {
+  let ctsContent = replaceAll({
+    $string: content,
+    replacer: "from '$<ImportPath>.cjs';",
+    searchValue: STATIC_IMPORT_REG_EXP
+  });
+  ctsContent = replaceAll({
+    $string: ctsContent,
+    replacer: "import($<Quote>$<ImportPath>.cjs$<Quote>)",
+    searchValue: DYNAMIC_IMPORT_REG_EXP
+  });
+  ctsContent = replaceAll({
+    $string: ctsContent,
+    replacer: "import type $<Clause> from '$<Specifier>' with { 'resolution-mode': 'import' };",
+    searchValue: BARE_TYPE_IMPORT_REG_EXP
+  });
+  return replaceAll({
+    $string: ctsContent,
+    replacer: `import("$<Specifier>", { with: { 'resolution-mode': 'import' } })`,
+    searchValue: BARE_INLINE_IMPORT_TYPE_REG_EXP
+  });
+}
+function toDistPath(params) {
+  return normalizeIfRelative(join(RepoPaths.DistLib, params.format, params.importPath, params.name));
+}
+function toMtsContent(content) {
+  const mtsContent = replaceAll({
+    $string: content,
+    replacer: "from '$<ImportPath>.mjs';",
+    searchValue: STATIC_IMPORT_REG_EXP
+  });
+  return replaceAll({
+    $string: mtsContent,
+    replacer: "import($<Quote>$<ImportPath>.mjs$<Quote>)",
+    searchValue: DYNAMIC_IMPORT_REG_EXP
+  });
+}
+async function writeSubpathPackageJson(folder, packageJson) {
+  await mkdir(folder, { recursive: true });
+  await writeJson(join(folder, RepoPaths.PackageJson), packageJson);
+}
+export {
+  LIBRARY_BANNER,
+  LIBRARY_BUILD_STEPS,
+  SOURCE_CONDITION,
+  buildCleanLibrary,
+  buildLibrary,
+  buildLibraryTypes,
+  generateLibraryExports,
+  generateLibraryIndex,
+  runBuildSteps
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/library-build.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The build pipeline of a TypeScript LIBRARY package: one `dist/lib/{cjs,esm}` tree of unbundled modules beside its\n * `.d.cts` / `.d.mts` declarations, the generated `index.ts` barrels, and the generated `package.json` `exports` map.\n *\n * Each step works on the current working folder, which is the package being built. A repository's\n * `scripts/build-*.ts` entry points are thin `wrapCliTask` wrappers around these functions, and its `build` script\n * runs them in order through {@link runBuildSteps}.\n */\n\nimport type {\n  BuildOptions,\n  Plugin\n} from 'esbuild';\nimport type { Dirent } from 'node:fs';\n\nimport { asyncMap } from '@mnaoumov/typescript-lib/async';\nimport { isDeepEqual } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  normalizeIfRelative,\n  relative\n} from '@mnaoumov/typescript-lib/path';\nimport { replaceAll } from '@mnaoumov/typescript-lib/string';\nimport { context } from 'esbuild';\nimport {\n  existsSync,\n  readFileSync\n} from 'node:fs';\nimport {\n  mkdir,\n  readFile,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { relative as relativeNative } from 'node:path';\nimport process from 'node:process';\n\nimport type { PackageJson } from './npm.ts';\n\nimport { buildClean } from './build.ts';\nimport { changeExtensionPlugin } from './bundlers/esbuild-impl/change-extension-plugin.ts';\nimport { fixEsmPlugin } from './bundlers/esbuild-impl/fix-esm-plugin.ts';\nimport { preprocessPlugin } from './bundlers/esbuild-impl/preprocess-plugin.ts';\nimport { parseTsConfig } from './check-project-types.ts';\nimport { generate } from './code-generator.ts';\nimport { readdirPosix } from './fs.ts';\nimport { writeJson } from './json.ts';\nimport { npmRunOptional } from './npm-run.ts';\nimport { editPackageJson } from './npm.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport { execFromRoot } from './root.ts';\n\n/**\n * The banner every emitted library module opens with.\n */\nexport const LIBRARY_BANNER = `/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n`;\n\n/**\n * The steps of a library build, in the order {@link runBuildSteps} runs them.\n */\nexport const LIBRARY_BUILD_STEPS: readonly string[] = [\n  'build:clean',\n  'build:generate-index',\n  'build:compile',\n  'build:types',\n  'build:validate-declarations',\n  'build:lib',\n  'build:generate-exports'\n];\n\n/**\n * The export condition the `obsidian-dev-utils` workspace maps every subpath onto its TypeScript source with, so a\n * package there can import a sibling package's source before anything is built. Pass it to\n * {@link generateLibraryExports} through {@link GenerateLibraryExportsOptions.sourceCondition}.\n */\nexport const SOURCE_CONDITION = '@mnaoumov/source';\n\n/**\n * Options for {@link buildLibrary}.\n */\nexport interface BuildLibraryOptions {\n  /**\n   * Creates the preprocess plugin for one output format. Defaults to the generic one, which carries no\n   * environment-specific `require` patch.\n   */\n  readonly preprocessPluginFactory?: (isEsm: boolean) => Plugin;\n}\n\n/**\n * Options for {@link generateLibraryExports}.\n */\nexport interface GenerateLibraryExportsOptions {\n  /**\n   * An export condition to put first in every entry, mapping the subpath onto its TypeScript source. Only a\n   * repository holding several packages that import each other needs one; nothing outside it sets the condition, and\n   * the sources it points at do not ship, so the publish has to strip it again. Omitted, the map has none.\n   */\n  readonly sourceCondition?: string | undefined;\n}\n\ntype ModuleFormat = 'cjs' | 'esm';\n\nconst DECLARATION_REFERENCE_TYPES = new Set(['node']);\n// Spelled apart on purpose: {@link collectAllLibs} scans every source file of the package being built for the\n// directive, this one included, so a literal one here would be read as a lib this package needs.\nconst REFERENCE_LIB_DIRECTIVE = ['<reference', 'lib='].join(' ');\nconst REFERENCE_LIB_REG_EXP = /\\/\\/\\/ <reference lib=\"(?<Lib>[^\"]+)\" \\/>/gm;\n\n// A bare-specifier (non-relative) type-only import, e.g. `import type { Promisable } from 'type-fest';`.\nconst BARE_TYPE_IMPORT_REG_EXP = /^import type (?<Clause>.+?) from '(?<Specifier>[^.'][^']*)';$/gm;\n\n// A bare-specifier (non-relative) inline import type node, e.g. `import(\"type-fest\").Promisable`.\nconst BARE_INLINE_IMPORT_TYPE_REG_EXP = /import\\(\"(?<Specifier>[^.\"][^\"]*)\"\\)/g;\n\nconst STATIC_IMPORT_REG_EXP = /from '(?<ImportPath>.+?)\\.ts';/gm;\n\n// Inline import-type nodes (`typeof import('./foo.ts')`) preserve the source quote style.\n// Hand-authored `.d.ts` files emit single quotes; tsc-generated declarations emit double quotes.\n// Capture the quote and reuse it in the replacement so both styles are rewritten.\nconst DYNAMIC_IMPORT_REG_EXP = /import\\((?<Quote>['\"])(?<ImportPath>.+?)\\.ts\\k<Quote>\\)/gm;\n\nenum GenerateIndexResult {\n  Skipped = 'skipped',\n  Success = 'success'\n}\n\ninterface BuildLibraryFormatParams {\n  readonly format: ModuleFormat;\n  readonly libFiles: string[];\n  readonly preprocessPluginFactory: (isEsm: boolean) => Plugin;\n}\n\ninterface BuildReferencePathDirectiveParams {\n  readonly declarationFilePath: string;\n  readonly extension: string;\n  readonly libraryFileName: string;\n  readonly moduleDirectory: string;\n}\n\ninterface SetExportParams {\n  readonly exportConditions: PackageJson.ExportConditions;\n  readonly isWildcard: boolean;\n  readonly sourceCondition: string | undefined;\n  readonly srcFolder: string;\n}\n\ninterface ToDistPathParams {\n  readonly format: string;\n  readonly importPath: string;\n  readonly name: string;\n}\n\n/**\n * Removes everything an earlier build left: `dist/`, the generated `index.ts` barrels, the `.d.ts` files `tsc` wrote\n * beside the sources (hand-authored ones under `@types` stay), and the per-subpath `package.json` stubs.\n *\n * @returns A {@link Promise} that resolves when everything has been removed.\n */\nexport async function buildCleanLibrary(): Promise<void> {\n  await buildClean();\n  for (const file of await readdirPosix(RepoPaths.Src, { recursive: true })) {\n    if (basename(file) === RepoPaths.IndexTs as string) {\n      await rm(join(RepoPaths.Src, file));\n    }\n\n    if (file.endsWith(RepoPaths.DtsExtension) && !file.split('/').includes(RepoPaths.Types)) {\n      await rm(join(RepoPaths.Src, file));\n    }\n  }\n\n  for (const file of await readdirPosix(RepoPaths.CurrentFolder, { recursive: true })) {\n    if ((basename(file) !== RepoPaths.PackageJson as string) || (file === RepoPaths.PackageJson as string) || file.startsWith(RepoPaths.NodeModules)) {\n      continue;\n    }\n\n    await rm(file);\n  }\n}\n\n/**\n * Builds every source module, unbundled, into `dist/lib/cjs` (`.cjs`) and `dist/lib/esm` (`.mjs`).\n *\n * The output folders must already exist; {@link buildLibraryTypes} creates them.\n *\n * @param options - The build options.\n * @returns A {@link Promise} that resolves when both formats have been built.\n */\nexport async function buildLibrary(options: BuildLibraryOptions = {}): Promise<void> {\n  const { preprocessPluginFactory = (isEsm: boolean): Plugin => preprocessPlugin({ isEsm }) } = options;\n  const libFiles = await getLibFiles();\n  await buildLibraryFormat({ format: 'cjs', libFiles, preprocessPluginFactory });\n  await buildLibraryFormat({ format: 'esm', libFiles, preprocessPluginFactory });\n}\n\n/**\n * Emits the declarations with `tsc --project ./tsconfig.types.json`, then copies each one into `dist/lib` twice: as a\n * `.d.cts` whose relative imports name `.cjs` files and whose bare type imports carry `resolution-mode: import`, and\n * as a `.d.mts` whose relative imports name `.mjs` files.\n *\n * The library's root declaration (`library.ts` where the package has one, otherwise the generated `index.ts`) carries\n * every `lib` and `types` reference the package needs; every other declaration references it by path.\n *\n * @returns A {@link Promise} that resolves when the declarations have been written.\n */\nexport async function buildLibraryTypes(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--project', './tsconfig.types.json']);\n\n  const libraryFileName = existsSync(join(RepoPaths.Src, 'library.ts')) ? 'library' : 'index';\n  const allLibs = await collectAllLibs();\n  const allTypes = collectAllTypes();\n\n  for (const file of await readdirPosix(RepoPaths.Src, { recursive: true })) {\n    if (!file.endsWith(RepoPaths.DtsExtension) || file.startsWith(RepoPaths.TestHelpers)) {\n      continue;\n    }\n\n    const folder = dirname(file);\n    const name = basename(file, RepoPaths.DtsExtension);\n    const content = await readFile(join(RepoPaths.Src, file), 'utf-8');\n\n    const ctsPath = join(RepoPaths.DistLib, RepoPaths.Cjs, folder, name + RepoPaths.DctsExtension);\n    const mtsPath = join(RepoPaths.DistLib, RepoPaths.Esm, folder, name + RepoPaths.DmtsExtension);\n\n    await mkdir(dirname(ctsPath), { recursive: true });\n    await mkdir(dirname(mtsPath), { recursive: true });\n\n    let ctsContent = toCtsContent(content);\n    let mtsContent = toMtsContent(content);\n\n    if (name === libraryFileName && folder === '.') {\n      const directives = buildAllReferenceLibDirectives(allLibs) + buildAllReferenceTypesDirectives(allTypes);\n      ctsContent = directives + ctsContent;\n      mtsContent = directives + mtsContent;\n    } else {\n      ctsContent = buildReferencePathDirective({ declarationFilePath: ctsPath, extension: RepoPaths.DctsExtension, libraryFileName, moduleDirectory: RepoPaths.Cjs })\n        + ctsContent;\n      mtsContent = buildReferencePathDirective({ declarationFilePath: mtsPath, extension: RepoPaths.DmtsExtension, libraryFileName, moduleDirectory: RepoPaths.Esm })\n        + mtsContent;\n    }\n\n    await writeFile(ctsPath, ctsContent);\n    await writeFile(mtsPath, mtsContent);\n  }\n}\n\n/**\n * Regenerates the `exports` map of the package's `package.json` from its source folders, and writes a `package.json`\n * stub per subpath for resolvers that do not read `exports`.\n *\n * @param options - The {@link GenerateLibraryExportsOptions}.\n * @returns A {@link Promise} that resolves when the map is current.\n * @throws If the map changed, so the change gets reviewed and committed rather than shipped unseen.\n */\nexport async function generateLibraryExports(options: GenerateLibraryExportsOptions = {}): Promise<void> {\n  const { sourceCondition } = options;\n  const srcFolders: string[] = [RepoPaths.Src];\n\n  for (const dirent of await readdirPosix(RepoPaths.Src, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isDirectory()) {\n      continue;\n    }\n\n    const path = join(dirent.parentPath, dirent.name);\n\n    if (path.includes(RepoPaths.Styles) || path.includes(RepoPaths.TestHelpers)) {\n      continue;\n    }\n\n    srcFolders.push(path);\n  }\n\n  srcFolders.sort();\n\n  let isChanged = false;\n\n  await editPackageJson(async (packageJson) => {\n    const oldExports = packageJson.exports;\n    const exportConditions: PackageJson.ExportConditions = {};\n    packageJson.exports = exportConditions;\n    for (const srcFolder of srcFolders) {\n      await setExport({ exportConditions, isWildcard: false, sourceCondition, srcFolder });\n      await setExport({ exportConditions, isWildcard: true, sourceCondition, srcFolder });\n    }\n\n    isChanged = !isDeepEqual(oldExports, packageJson.exports);\n  });\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It changed in the `editPackageJson`, ESLint mistakenly does not recognize it.\n  if (isChanged) {\n    throw new Error('Package exports have changed. Please review the changes and commit them.');\n  }\n}\n\n/**\n * Generates an `index.ts` barrel in every source folder that has something to export, re-exporting each module and\n * each sub-barrel under its own name.\n *\n * @returns A {@link Promise} that resolves when the barrels have been written.\n */\nexport async function generateLibraryIndex(): Promise<void> {\n  await generateIndex(RepoPaths.Src);\n}\n\n/**\n * Runs each named npm script the package defines, in order, skipping the ones it does not define.\n *\n * @param steps - The npm script names.\n * @returns A {@link Promise} that resolves when every step has run.\n */\nexport async function runBuildSteps(steps: readonly string[] = LIBRARY_BUILD_STEPS): Promise<void> {\n  for (const step of steps) {\n    await npmRunOptional(step);\n  }\n}\n\nfunction buildAllReferenceLibDirectives(libs: string[]): string {\n  return `${\n    libs\n      .map((lib) => `/// ${REFERENCE_LIB_DIRECTIVE}\"${lib}\" />`)\n      .join('\\n')\n  }\\n`;\n}\n\nfunction buildAllReferenceTypesDirectives(types: string[]): string {\n  return types.length === 0\n    ? ''\n    : `${\n      types\n        .map((type) => `/// <reference types=\"${type}\" />`)\n        .join('\\n')\n    }\\n`;\n}\n\nasync function buildLibraryFormat(params: BuildLibraryFormatParams): Promise<void> {\n  const { format, libFiles, preprocessPluginFactory } = params;\n  const extension = format === 'cjs' ? RepoPaths.CjsExtension : RepoPaths.MjsExtension;\n  const buildOptions: BuildOptions = {\n    // Explicit, because esbuild otherwise takes the folder its service process started in.\n    // eslint-disable-next-line unicorn/name-replacements -- esbuild's own option name.\n    absWorkingDir: process.cwd(),\n    banner: {\n      js: LIBRARY_BANNER\n    },\n    bundle: false,\n    entryPoints: libFiles,\n    format,\n    logLevel: 'info',\n    outdir: join(RepoPaths.DistLib, format),\n    platform: 'node',\n    plugins: [\n      preprocessPluginFactory(format === 'esm'),\n      fixEsmPlugin(),\n      changeExtensionPlugin(extension)\n    ],\n    sourcemap: 'inline',\n    target: 'ES2022',\n    treeShaking: true,\n    write: false\n  };\n\n  const buildContext = await context(buildOptions);\n  try {\n    await buildContext.rebuild();\n  } finally {\n    await buildContext.dispose();\n  }\n}\n\nfunction buildReferencePathDirective(params: BuildReferencePathDirectiveParams): string {\n  const { declarationFilePath, extension, libraryFileName, moduleDirectory } = params;\n  const libraryFilePath = join(RepoPaths.DistLib, moduleDirectory, libraryFileName + extension);\n  let relativePath = relativeNative(dirname(declarationFilePath), libraryFilePath).replaceAll('\\\\', '/');\n  if (!relativePath.startsWith('.')) {\n    relativePath = `./${relativePath}`;\n  }\n  return `/// <reference path=\"${relativePath}\" />\\n`;\n}\n\nasync function collectAllLibs(): Promise<string[]> {\n  // The RESOLVED options, because a package's `tsconfig.json` inherits `lib` from the shared base. The resolved\n  // names are file names (`lib.dom.iterable.d.ts`), so they are mapped back onto the names a directive takes.\n  const { options } = parseTsConfig(RepoPaths.TsConfigJson);\n  const libs = new Set((options.lib ?? []).map((lib) => lib.toLowerCase().replace(/^lib\\./, '').replace(/\\.d\\.ts$/, '')));\n\n  for (const file of await readdirPosix(RepoPaths.Src, { recursive: true })) {\n    if (!file.endsWith('.ts')) {\n      continue;\n    }\n\n    const sourceContent = readFileSync(join(RepoPaths.Src, file), 'utf-8');\n    // The regular expression always captures its one group, so no fallback for a missing one is needed.\n    for (const [, lib] of sourceContent.matchAll(REFERENCE_LIB_REG_EXP)) {\n      libs.add(String(lib).toLowerCase());\n    }\n  }\n\n  return [...libs].sort();\n}\n\nfunction collectAllTypes(): string[] {\n  const { options } = parseTsConfig(RepoPaths.TsConfigJson);\n  return (options.types ?? [])\n    .filter((type) => DECLARATION_REFERENCE_TYPES.has(type))\n    .sort();\n}\n\nasync function generateIndex(folder: string): Promise<GenerateIndexResult> {\n  const dirents = await readdirPosix(folder, { withFileTypes: true });\n  const maybeLines = await asyncMap(dirents, (dirent) => handleIndexDirent(folder, dirent));\n  const lines = maybeLines.filter((line) => line !== undefined);\n\n  if (lines.length === 0) {\n    return GenerateIndexResult.Skipped;\n  }\n\n  await generate(join(folder, RepoPaths.IndexTs), lines);\n  return GenerateIndexResult.Success;\n}\n\nasync function getLibFiles(): Promise<string[]> {\n  let files = await readdirPosix(RepoPaths.Src, { recursive: true });\n  files = files.map((file) => normalizeIfRelative(join(RepoPaths.Src, file)));\n  return files.filter((file) =>\n    file.endsWith(RepoPaths.TsExtension) && !file.endsWith(RepoPaths.DtsExtension) && !file.endsWith('.test.ts')\n    && !file.includes(`/${RepoPaths.TestHelpers}/`)\n  );\n}\n\nasync function handleIndexDirent(folder: string, dirent: Dirent): Promise<string | undefined> {\n  if (isExcludedFromIndex(folder, dirent)) {\n    return;\n  }\n\n  let sourceFile: string;\n  let name: string;\n  if (dirent.isDirectory()) {\n    const result = await generateIndex(join(folder, dirent.name));\n    if (result !== GenerateIndexResult.Success) {\n      return;\n    }\n    sourceFile = normalizeIfRelative(join(dirent.name, RepoPaths.IndexTs));\n    name = dirent.name;\n  } else {\n    const extension = extname(dirent.name);\n    name = basename(dirent.name, extension);\n    sourceFile = normalizeIfRelative(dirent.name);\n  }\n\n  return `export * as '${name}' from '${sourceFile}';`;\n}\n\nfunction isExcludedFileName(name: string): boolean {\n  return !name.endsWith(RepoPaths.TsExtension) || name.endsWith('.test.ts') || name === 'setup.ts' || name.endsWith('-setup.ts');\n}\n\nfunction isExcludedFromIndex(folder: string, dirent: Dirent): boolean {\n  const excludedNames: readonly string[] = [RepoPaths.IndexTs, RepoPaths.Types, RepoPaths.Styles, RepoPaths.TestHelpers];\n  const isExcludedEntry = excludedNames.includes(dirent.name) || dirent.name.endsWith(RepoPaths.DtsExtension) || folder.split('/').includes(RepoPaths.Types);\n  return isExcludedEntry || (dirent.isFile() && isExcludedFileName(dirent.name));\n}\n\nasync function setExport(params: SetExportParams): Promise<void> {\n  const { exportConditions, isWildcard, sourceCondition, srcFolder } = params;\n  const importPath = replaceAll({\n    $string: srcFolder,\n    replacer: RepoPaths.CurrentFolder,\n    searchValue: RepoPaths.Src\n  });\n  const conditionPath = isWildcard ? `${importPath}/${RepoPaths.Any}` : importPath;\n  const dmtsPath = toDistPath({ format: RepoPaths.Esm, importPath, name: isWildcard ? RepoPaths.AnyDmts : RepoPaths.IndexDmts });\n  const dctsPath = toDistPath({ format: RepoPaths.Cjs, importPath, name: isWildcard ? RepoPaths.AnyDcts : RepoPaths.IndexDcts });\n  const dmtsFolderPath = dirname(dmtsPath);\n  const dctsFolderPath = dirname(dctsPath);\n\n  if (!isWildcard && !existsSync(dctsPath)) {\n    return;\n  }\n\n  const isTypesOnly = importPath.includes(RepoPaths.Types);\n  const mjsPath = toDistPath({ format: RepoPaths.Esm, importPath, name: isWildcard ? RepoPaths.AnyMjs : RepoPaths.IndexMjs });\n  const cjsPath = toDistPath({ format: RepoPaths.Cjs, importPath, name: isWildcard ? RepoPaths.AnyCjs : RepoPaths.IndexCjs });\n\n  if (isTypesOnly) {\n    exportConditions[conditionPath] = {\n      import: {\n        types: dmtsPath\n      },\n      require: {\n        types: dctsPath\n      }\n    };\n  } else {\n    const sourcePath = normalizeIfRelative(join(RepoPaths.Src, importPath, isWildcard ? RepoPaths.AnyTs : RepoPaths.IndexTs));\n\n    exportConditions[conditionPath] = {\n      /* eslint-disable perfectionist/sort-objects -- Order matters once it is written to `package.json`. */\n      // First, so it wins wherever it is set: inside the repository, before anything is built.\n      ...(sourceCondition !== undefined && { [sourceCondition]: sourcePath }),\n      import: {\n        types: dmtsPath,\n        default: mjsPath\n      },\n      require: {\n        types: dctsPath,\n        default: cjsPath\n      }\n      /* eslint-enable perfectionist/sort-objects -- Order matters once it is written to `package.json`. */\n    };\n  }\n\n  if (importPath === RepoPaths.CurrentFolder as string) {\n    return;\n  }\n\n  if (!isWildcard) {\n    await writeSubpathPackageJson(\n      importPath,\n      isTypesOnly\n        ? { type: 'module', types: relative(importPath, dctsPath) }\n        : { main: relative(importPath, cjsPath), module: relative(importPath, mjsPath), type: 'module', types: relative(importPath, dctsPath) }\n    );\n    return;\n  }\n\n  for (const file of await readdirPosix(dctsFolderPath)) {\n    if (!file.endsWith(RepoPaths.DctsExtension)) {\n      continue;\n    }\n    const name = basename(file, RepoPaths.DctsExtension);\n    const packageJsonFolderPath = join(importPath, name);\n    const types = relative(packageJsonFolderPath, join(dctsFolderPath, name + RepoPaths.DctsExtension));\n    await writeSubpathPackageJson(\n      packageJsonFolderPath,\n      isTypesOnly\n        ? { type: 'module', types }\n        : {\n          main: relative(packageJsonFolderPath, join(dctsFolderPath, name + RepoPaths.CjsExtension)),\n          module: relative(packageJsonFolderPath, join(dmtsFolderPath, name + RepoPaths.MjsExtension)),\n          type: 'module',\n          types\n        }\n    );\n  }\n}\n\nfunction toCtsContent(content: string): string {\n  let ctsContent = replaceAll({\n    $string: content,\n    replacer: 'from \\'$<ImportPath>.cjs\\';',\n    searchValue: STATIC_IMPORT_REG_EXP\n  });\n  ctsContent = replaceAll({\n    $string: ctsContent,\n    replacer: 'import($<Quote>$<ImportPath>.cjs$<Quote>)',\n    searchValue: DYNAMIC_IMPORT_REG_EXP\n  });\n\n  // A `.d.cts` file is a CommonJS module. Type-only imports of a bare specifier resolving to an\n  // ESM-only package need a `resolution-mode` attribute, else `tsc` reports TS1541 / TS1542.\n  // Passing `'import'` is valid for CommonJS targets too, so every bare specifier receives it.\n  // The ESM `.d.mts` needs no such attribute, so this transform runs on CommonJS content only.\n  ctsContent = replaceAll({\n    $string: ctsContent,\n    replacer: 'import type $<Clause> from \\'$<Specifier>\\' with { \\'resolution-mode\\': \\'import\\' };',\n    searchValue: BARE_TYPE_IMPORT_REG_EXP\n  });\n  return replaceAll({\n    $string: ctsContent,\n    replacer: 'import(\"$<Specifier>\", { with: { \\'resolution-mode\\': \\'import\\' } })',\n    searchValue: BARE_INLINE_IMPORT_TYPE_REG_EXP\n  });\n}\n\nfunction toDistPath(params: ToDistPathParams): string {\n  return normalizeIfRelative(join(RepoPaths.DistLib, params.format, params.importPath, params.name));\n}\n\nfunction toMtsContent(content: string): string {\n  const mtsContent = replaceAll({\n    $string: content,\n    replacer: 'from \\'$<ImportPath>.mjs\\';',\n    searchValue: STATIC_IMPORT_REG_EXP\n  });\n  return replaceAll({\n    $string: mtsContent,\n    replacer: 'import($<Quote>$<ImportPath>.mjs$<Quote>)',\n    searchValue: DYNAMIC_IMPORT_REG_EXP\n  });\n}\n\nasync function writeSubpathPackageJson(folder: string, packageJson: PackageJson): Promise<void> {\n  await mkdir(folder, { recursive: true });\n  await writeJson(join(folder, RepoPaths.PackageJson), packageJson);\n}\n"],
  "mappings": "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",
  "names": []
}
