@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/library-build.cjs

@@ -0,0 +1,475 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var library_build_exports = {};
+__export(library_build_exports, {
+  LIBRARY_BANNER: () => LIBRARY_BANNER,
+  LIBRARY_BUILD_STEPS: () => LIBRARY_BUILD_STEPS,
+  SOURCE_CONDITION: () => SOURCE_CONDITION,
+  buildCleanLibrary: () => buildCleanLibrary,
+  buildLibrary: () => buildLibrary,
+  buildLibraryTypes: () => buildLibraryTypes,
+  generateLibraryExports: () => generateLibraryExports,
+  generateLibraryIndex: () => generateLibraryIndex,
+  runBuildSteps: () => runBuildSteps
+});
+module.exports = __toCommonJS(library_build_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_string = require('@mnaoumov/typescript-lib/string');
+var import_esbuild = require('esbuild');
+var import_node_fs = require('node:fs');
+var import_promises = require('node:fs/promises');
+var import_node_path = require('node:path');
+var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_build = require('./build.cjs');
+var import_change_extension_plugin = require('./bundlers/esbuild-impl/change-extension-plugin.cjs');
+var import_fix_esm_plugin = require('./bundlers/esbuild-impl/fix-esm-plugin.cjs');
+var import_preprocess_plugin = require('./bundlers/esbuild-impl/preprocess-plugin.cjs');
+var import_check_project_types = require('./check-project-types.cjs');
+var import_code_generator = require('./code-generator.cjs');
+var import_fs = require('./fs.cjs');
+var import_json = require('./json.cjs');
+var import_npm_run = require('./npm-run.cjs');
+var import_npm = require('./npm.cjs');
+var import_package_manager = require('./package-manager.cjs');
+var import_repo_paths = require('./repo-paths.cjs');
+var import_root = require('./root.cjs');
+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 (0, import_build.buildClean)();
+  for (const file of await (0, import_fs.readdirPosix)(import_repo_paths.RepoPaths.Src, { recursive: true })) {
+    if ((0, import_path.basename)(file) === import_repo_paths.RepoPaths.IndexTs) {
+      await (0, import_promises.rm)((0, import_path.join)(import_repo_paths.RepoPaths.Src, file));
+    }
+    if (file.endsWith(import_repo_paths.RepoPaths.DtsExtension) && !file.split("/").includes(import_repo_paths.RepoPaths.Types)) {
+      await (0, import_promises.rm)((0, import_path.join)(import_repo_paths.RepoPaths.Src, file));
+    }
+  }
+  for (const file of await (0, import_fs.readdirPosix)(import_repo_paths.RepoPaths.CurrentFolder, { recursive: true })) {
+    if ((0, import_path.basename)(file) !== import_repo_paths.RepoPaths.PackageJson || file === import_repo_paths.RepoPaths.PackageJson || file.startsWith(import_repo_paths.RepoPaths.NodeModules)) {
+      continue;
+    }
+    await (0, import_promises.rm)(file);
+  }
+}
+async function buildLibrary(options = {}) {
+  const { preprocessPluginFactory = (isEsm) => (0, import_preprocess_plugin.preprocessPlugin)({ isEsm }) } = options;
+  const libFiles = await getLibFiles();
+  await buildLibraryFormat({ format: "cjs", libFiles, preprocessPluginFactory });
+  await buildLibraryFormat({ format: "esm", libFiles, preprocessPluginFactory });
+}
+async function buildLibraryTypes() {
+  await (0, import_root.execFromRoot)([...(0, import_package_manager.resolveToolCommand)({ tool: "tsc" }), "--project", "./tsconfig.types.json"]);
+  const libraryFileName = (0, import_node_fs.existsSync)((0, import_path.join)(import_repo_paths.RepoPaths.Src, "library.ts")) ? "library" : "index";
+  const allLibs = await collectAllLibs();
+  const allTypes = collectAllTypes();
+  for (const file of await (0, import_fs.readdirPosix)(import_repo_paths.RepoPaths.Src, { recursive: true })) {
+    if (!file.endsWith(import_repo_paths.RepoPaths.DtsExtension) || file.startsWith(import_repo_paths.RepoPaths.TestHelpers)) {
+      continue;
+    }
+    const folder = (0, import_path.dirname)(file);
+    const name = (0, import_path.basename)(file, import_repo_paths.RepoPaths.DtsExtension);
+    const content = await (0, import_promises.readFile)((0, import_path.join)(import_repo_paths.RepoPaths.Src, file), "utf-8");
+    const ctsPath = (0, import_path.join)(import_repo_paths.RepoPaths.DistLib, import_repo_paths.RepoPaths.Cjs, folder, name + import_repo_paths.RepoPaths.DctsExtension);
+    const mtsPath = (0, import_path.join)(import_repo_paths.RepoPaths.DistLib, import_repo_paths.RepoPaths.Esm, folder, name + import_repo_paths.RepoPaths.DmtsExtension);
+    await (0, import_promises.mkdir)((0, import_path.dirname)(ctsPath), { recursive: true });
+    await (0, import_promises.mkdir)((0, import_path.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: import_repo_paths.RepoPaths.DctsExtension, libraryFileName, moduleDirectory: import_repo_paths.RepoPaths.Cjs }) + ctsContent;
+      mtsContent = buildReferencePathDirective({ declarationFilePath: mtsPath, extension: import_repo_paths.RepoPaths.DmtsExtension, libraryFileName, moduleDirectory: import_repo_paths.RepoPaths.Esm }) + mtsContent;
+    }
+    await (0, import_promises.writeFile)(ctsPath, ctsContent);
+    await (0, import_promises.writeFile)(mtsPath, mtsContent);
+  }
+}
+async function generateLibraryExports(options = {}) {
+  const { sourceCondition } = options;
+  const srcFolders = [import_repo_paths.RepoPaths.Src];
+  for (const dirent of await (0, import_fs.readdirPosix)(import_repo_paths.RepoPaths.Src, { recursive: true, withFileTypes: true })) {
+    if (!dirent.isDirectory()) {
+      continue;
+    }
+    const path = (0, import_path.join)(dirent.parentPath, dirent.name);
+    if (path.includes(import_repo_paths.RepoPaths.Styles) || path.includes(import_repo_paths.RepoPaths.TestHelpers)) {
+      continue;
+    }
+    srcFolders.push(path);
+  }
+  srcFolders.sort();
+  let isChanged = false;
+  await (0, import_npm.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 = !(0, import_object_utils.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(import_repo_paths.RepoPaths.Src);
+}
+async function runBuildSteps(steps = LIBRARY_BUILD_STEPS) {
+  for (const step of steps) {
+    await (0, import_npm_run.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" ? import_repo_paths.RepoPaths.CjsExtension : import_repo_paths.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: import_node_process.default.cwd(),
+    banner: {
+      js: LIBRARY_BANNER
+    },
+    bundle: false,
+    entryPoints: libFiles,
+    format,
+    logLevel: "info",
+    outdir: (0, import_path.join)(import_repo_paths.RepoPaths.DistLib, format),
+    platform: "node",
+    plugins: [
+      preprocessPluginFactory(format === "esm"),
+      (0, import_fix_esm_plugin.fixEsmPlugin)(),
+      (0, import_change_extension_plugin.changeExtensionPlugin)(extension)
+    ],
+    sourcemap: "inline",
+    target: "ES2022",
+    treeShaking: true,
+    write: false
+  };
+  const buildContext = await (0, import_esbuild.context)(buildOptions);
+  try {
+    await buildContext.rebuild();
+  } finally {
+    await buildContext.dispose();
+  }
+}
+function buildReferencePathDirective(params) {
+  const { declarationFilePath, extension, libraryFileName, moduleDirectory } = params;
+  const libraryFilePath = (0, import_path.join)(import_repo_paths.RepoPaths.DistLib, moduleDirectory, libraryFileName + extension);
+  let relativePath = (0, import_node_path.relative)((0, import_path.dirname)(declarationFilePath), libraryFilePath).replaceAll("\\", "/");
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+  return `/// <reference path="${relativePath}" />
+`;
+}
+async function collectAllLibs() {
+  const { options } = (0, import_check_project_types.parseTsConfig)(import_repo_paths.RepoPaths.TsConfigJson);
+  const libs = new Set((options.lib ?? []).map((lib) => lib.toLowerCase().replace(/^lib\./, "").replace(/\.d\.ts$/, "")));
+  for (const file of await (0, import_fs.readdirPosix)(import_repo_paths.RepoPaths.Src, { recursive: true })) {
+    if (!file.endsWith(".ts")) {
+      continue;
+    }
+    const sourceContent = (0, import_node_fs.readFileSync)((0, import_path.join)(import_repo_paths.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 } = (0, import_check_project_types.parseTsConfig)(import_repo_paths.RepoPaths.TsConfigJson);
+  return (options.types ?? []).filter((type) => DECLARATION_REFERENCE_TYPES.has(type)).sort();
+}
+async function generateIndex(folder) {
+  const dirents = await (0, import_fs.readdirPosix)(folder, { withFileTypes: true });
+  const maybeLines = await (0, import_async.asyncMap)(dirents, (dirent) => handleIndexDirent(folder, dirent));
+  const lines = maybeLines.filter((line) => line !== void 0);
+  if (lines.length === 0) {
+    return "skipped" /* Skipped */;
+  }
+  await (0, import_code_generator.generate)((0, import_path.join)(folder, import_repo_paths.RepoPaths.IndexTs), lines);
+  return "success" /* Success */;
+}
+async function getLibFiles() {
+  let files = await (0, import_fs.readdirPosix)(import_repo_paths.RepoPaths.Src, { recursive: true });
+  files = files.map((file) => (0, import_path.normalizeIfRelative)((0, import_path.join)(import_repo_paths.RepoPaths.Src, file)));
+  return files.filter(
+    (file) => file.endsWith(import_repo_paths.RepoPaths.TsExtension) && !file.endsWith(import_repo_paths.RepoPaths.DtsExtension) && !file.endsWith(".test.ts") && !file.includes(`/${import_repo_paths.RepoPaths.TestHelpers}/`)
+  );
+}
+async function handleIndexDirent(folder, dirent) {
+  if (isExcludedFromIndex(folder, dirent)) {
+    return;
+  }
+  let sourceFile;
+  let name;
+  if (dirent.isDirectory()) {
+    const result = await generateIndex((0, import_path.join)(folder, dirent.name));
+    if (result !== "success" /* Success */) {
+      return;
+    }
+    sourceFile = (0, import_path.normalizeIfRelative)((0, import_path.join)(dirent.name, import_repo_paths.RepoPaths.IndexTs));
+    name = dirent.name;
+  } else {
+    const extension = (0, import_path.extname)(dirent.name);
+    name = (0, import_path.basename)(dirent.name, extension);
+    sourceFile = (0, import_path.normalizeIfRelative)(dirent.name);
+  }
+  return `export * as '${name}' from '${sourceFile}';`;
+}
+function isExcludedFileName(name) {
+  return !name.endsWith(import_repo_paths.RepoPaths.TsExtension) || name.endsWith(".test.ts") || name === "setup.ts" || name.endsWith("-setup.ts");
+}
+function isExcludedFromIndex(folder, dirent) {
+  const excludedNames = [import_repo_paths.RepoPaths.IndexTs, import_repo_paths.RepoPaths.Types, import_repo_paths.RepoPaths.Styles, import_repo_paths.RepoPaths.TestHelpers];
+  const isExcludedEntry = excludedNames.includes(dirent.name) || dirent.name.endsWith(import_repo_paths.RepoPaths.DtsExtension) || folder.split("/").includes(import_repo_paths.RepoPaths.Types);
+  return isExcludedEntry || dirent.isFile() && isExcludedFileName(dirent.name);
+}
+async function setExport(params) {
+  const { exportConditions, isWildcard, sourceCondition, srcFolder } = params;
+  const importPath = (0, import_string.replaceAll)({
+    $string: srcFolder,
+    replacer: import_repo_paths.RepoPaths.CurrentFolder,
+    searchValue: import_repo_paths.RepoPaths.Src
+  });
+  const conditionPath = isWildcard ? `${importPath}/${import_repo_paths.RepoPaths.Any}` : importPath;
+  const dmtsPath = toDistPath({ format: import_repo_paths.RepoPaths.Esm, importPath, name: isWildcard ? import_repo_paths.RepoPaths.AnyDmts : import_repo_paths.RepoPaths.IndexDmts });
+  const dctsPath = toDistPath({ format: import_repo_paths.RepoPaths.Cjs, importPath, name: isWildcard ? import_repo_paths.RepoPaths.AnyDcts : import_repo_paths.RepoPaths.IndexDcts });
+  const dmtsFolderPath = (0, import_path.dirname)(dmtsPath);
+  const dctsFolderPath = (0, import_path.dirname)(dctsPath);
+  if (!isWildcard && !(0, import_node_fs.existsSync)(dctsPath)) {
+    return;
+  }
+  const isTypesOnly = importPath.includes(import_repo_paths.RepoPaths.Types);
+  const mjsPath = toDistPath({ format: import_repo_paths.RepoPaths.Esm, importPath, name: isWildcard ? import_repo_paths.RepoPaths.AnyMjs : import_repo_paths.RepoPaths.IndexMjs });
+  const cjsPath = toDistPath({ format: import_repo_paths.RepoPaths.Cjs, importPath, name: isWildcard ? import_repo_paths.RepoPaths.AnyCjs : import_repo_paths.RepoPaths.IndexCjs });
+  if (isTypesOnly) {
+    exportConditions[conditionPath] = {
+      import: {
+        types: dmtsPath
+      },
+      require: {
+        types: dctsPath
+      }
+    };
+  } else {
+    const sourcePath = (0, import_path.normalizeIfRelative)((0, import_path.join)(import_repo_paths.RepoPaths.Src, importPath, isWildcard ? import_repo_paths.RepoPaths.AnyTs : import_repo_paths.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 === import_repo_paths.RepoPaths.CurrentFolder) {
+    return;
+  }
+  if (!isWildcard) {
+    await writeSubpathPackageJson(
+      importPath,
+      isTypesOnly ? { type: "module", types: (0, import_path.relative)(importPath, dctsPath) } : { main: (0, import_path.relative)(importPath, cjsPath), module: (0, import_path.relative)(importPath, mjsPath), type: "module", types: (0, import_path.relative)(importPath, dctsPath) }
+    );
+    return;
+  }
+  for (const file of await (0, import_fs.readdirPosix)(dctsFolderPath)) {
+    if (!file.endsWith(import_repo_paths.RepoPaths.DctsExtension)) {
+      continue;
+    }
+    const name = (0, import_path.basename)(file, import_repo_paths.RepoPaths.DctsExtension);
+    const packageJsonFolderPath = (0, import_path.join)(importPath, name);
+    const types = (0, import_path.relative)(packageJsonFolderPath, (0, import_path.join)(dctsFolderPath, name + import_repo_paths.RepoPaths.DctsExtension));
+    await writeSubpathPackageJson(
+      packageJsonFolderPath,
+      isTypesOnly ? { type: "module", types } : {
+        main: (0, import_path.relative)(packageJsonFolderPath, (0, import_path.join)(dctsFolderPath, name + import_repo_paths.RepoPaths.CjsExtension)),
+        module: (0, import_path.relative)(packageJsonFolderPath, (0, import_path.join)(dmtsFolderPath, name + import_repo_paths.RepoPaths.MjsExtension)),
+        type: "module",
+        types
+      }
+    );
+  }
+}
+function toCtsContent(content) {
+  let ctsContent = (0, import_string.replaceAll)({
+    $string: content,
+    replacer: "from '$<ImportPath>.cjs';",
+    searchValue: STATIC_IMPORT_REG_EXP
+  });
+  ctsContent = (0, import_string.replaceAll)({
+    $string: ctsContent,
+    replacer: "import($<Quote>$<ImportPath>.cjs$<Quote>)",
+    searchValue: DYNAMIC_IMPORT_REG_EXP
+  });
+  ctsContent = (0, import_string.replaceAll)({
+    $string: ctsContent,
+    replacer: "import type $<Clause> from '$<Specifier>' with { 'resolution-mode': 'import' };",
+    searchValue: BARE_TYPE_IMPORT_REG_EXP
+  });
+  return (0, import_string.replaceAll)({
+    $string: ctsContent,
+    replacer: `import("$<Specifier>", { with: { 'resolution-mode': 'import' } })`,
+    searchValue: BARE_INLINE_IMPORT_TYPE_REG_EXP
+  });
+}
+function toDistPath(params) {
+  return (0, import_path.normalizeIfRelative)((0, import_path.join)(import_repo_paths.RepoPaths.DistLib, params.format, params.importPath, params.name));
+}
+function toMtsContent(content) {
+  const mtsContent = (0, import_string.replaceAll)({
+    $string: content,
+    replacer: "from '$<ImportPath>.mjs';",
+    searchValue: STATIC_IMPORT_REG_EXP
+  });
+  return (0, import_string.replaceAll)({
+    $string: mtsContent,
+    replacer: "import($<Quote>$<ImportPath>.mjs$<Quote>)",
+    searchValue: DYNAMIC_IMPORT_REG_EXP
+  });
+}
+async function writeSubpathPackageJson(folder, packageJson) {
+  await (0, import_promises.mkdir)(folder, { recursive: true });
+  await (0, import_json.writeJson)((0, import_path.join)(folder, import_repo_paths.RepoPaths.PackageJson), packageJson);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": ["process", "relativeNative"]
}
