@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/build/providers/mkdist/mkdist-impl/utils/dts.js

@@ -1,94 +0,0 @@
-import { statSync } from "node:fs";
-import { resolve } from "@reliverse/pathkit";
-import { findDynamicImports, findExports, findStaticImports, findTypeExports } from "mlly";
-export async function normalizeCompilerOptions(_options) {
-  const ts = await import("typescript").then((r) => r.default || r);
-  return ts.convertCompilerOptionsFromJson(_options, process.cwd()).options;
-}
-export async function getDeclarations(vfs, opts) {
-  const ts = await import("typescript").then((r) => r.default || r);
-  const inputFiles = [...vfs.keys()];
-  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
-  tsHost.writeFile = (fileName, declaration) => {
-    vfs.set(fileName, declaration);
-  };
-  const _readFile = tsHost.readFile;
-  tsHost.readFile = (filename) => {
-    if (vfs.has(filename)) {
-      return vfs.get(filename);
-    }
-    return _readFile(filename);
-  };
-  const program = ts.createProgram(inputFiles, opts.typescript.compilerOptions, tsHost);
-  const result = program.emit();
-  const output = extractDeclarations(vfs, inputFiles, opts);
-  augmentWithDiagnostics(result, output, tsHost, ts);
-  return output;
-}
-const JS_EXT_RE = /\.(m|c)?(ts|js)$/;
-const JSX_EXT_RE = /\.(m|c)?(ts|js)x?$/;
-const RELATIVE_RE = /^\.{1,2}[/\\]/;
-export function extractDeclarations(vfs, inputFiles, opts) {
-  const output = {};
-  for (const filename of inputFiles) {
-    const dtsFilename = filename.replace(JSX_EXT_RE, ".d.$1ts");
-    let contents = vfs.get(dtsFilename) || "";
-    if (opts?.addRelativeDeclarationExtensions) {
-      const ext = filename.match(JS_EXT_RE)?.[0].replace(/ts$/, "js") || ".js";
-      const imports = findStaticImports(contents);
-      const exports = findExports(contents);
-      const typeExports = findTypeExports(contents);
-      const dynamicImports = findDynamicImports(contents).map((dynamicImport) => {
-        let specifier;
-        try {
-          const value = JSON.parse(dynamicImport.expression);
-          if (typeof value === "string") {
-            specifier = value;
-          }
-        } catch {
-        }
-        return {
-          code: dynamicImport.code,
-          specifier
-        };
-      });
-      for (const spec of [...exports, ...typeExports, ...imports, ...dynamicImports]) {
-        if (!spec.specifier || !RELATIVE_RE.test(spec.specifier)) {
-          continue;
-        }
-        const srcPath = resolve(filename, "..", spec.specifier);
-        const srcDtsPath = srcPath + ext.replace(JS_EXT_RE, ".d.$1ts");
-        let specifier = spec.specifier;
-        try {
-          if (!vfs.get(srcDtsPath)) {
-            const stat = statSync(srcPath);
-            if (stat.isDirectory()) {
-              specifier += "/index";
-            }
-          }
-        } catch {
-        }
-        contents = contents.replace(spec.code, spec.code.replace(spec.specifier, specifier + ext));
-      }
-    }
-    output[filename] = { contents };
-    vfs.delete(filename);
-  }
-  return output;
-}
-export function augmentWithDiagnostics(result, output, tsHost, ts) {
-  if (result.diagnostics?.length) {
-    for (const diagnostic of result.diagnostics) {
-      const filename = diagnostic.file?.fileName;
-      if (filename in output) {
-        output[filename].errors = output[filename].errors || [];
-        output[filename].errors.push(
-          new TypeError(ts.formatDiagnostics([diagnostic], tsHost), {
-            cause: diagnostic
-          })
-        );
-      }
-    }
-    console.error(ts.formatDiagnostics(result.diagnostics, tsHost));
-  }
-}

package/bin/impl/build/providers/mkdist/mkdist-impl/utils/fs.d.ts

@@ -1 +0,0 @@
-export declare function copyFileWithStream(sourcePath: string, outPath: string): Promise<unknown>;

package/bin/impl/build/providers/mkdist/mkdist-impl/utils/fs.js

@@ -1,15 +0,0 @@
-import { createReadStream, createWriteStream } from "node:fs";
-import { pipeline } from "node:stream";
-export function copyFileWithStream(sourcePath, outPath) {
-  const sourceStream = createReadStream(sourcePath);
-  const outStream = createWriteStream(outPath);
-  return new Promise((resolve, reject) => {
-    pipeline(sourceStream, outStream, (error) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-}

package/bin/impl/build/providers/mkdist/mkdist-impl/utils/vue-dts.d.ts

@@ -1,3 +0,0 @@
-import type { MkdistOptions } from "../../../../../types/mod.js";
-import type { DeclarationOutput } from "./dts";
-export declare function getVueDeclarations(vfs: Map<string, string>, opts?: MkdistOptions): Promise<DeclarationOutput>;

package/bin/impl/build/providers/mkdist/mkdist-impl/utils/vue-dts.js

@@ -1,175 +0,0 @@
-import { createRequire } from "node:module";
-import { normalize } from "@reliverse/pathkit";
-import { satisfies } from "semver";
-import { augmentWithDiagnostics, extractDeclarations } from "./dts.js";
-const require = createRequire(import.meta.url);
-export async function getVueDeclarations(vfs, opts) {
-  const fileMapping = getFileMapping(vfs);
-  const srcFiles = Object.keys(fileMapping);
-  const originFiles = Object.values(fileMapping);
-  if (originFiles.length === 0) {
-    return;
-  }
-  const { readPackageJSON } = await import("pkg-types");
-  const pkgInfo = await readPackageJSON("vue-tsc").catch(() => {
-  });
-  if (!pkgInfo) {
-    console.warn("[mkdist] Please install `vue-tsc` to generate Vue SFC declarations.");
-    return;
-  }
-  const { version } = pkgInfo;
-  let output;
-  switch (true) {
-    // @ts-expect-error TODO: fix ts
-    case satisfies(version, "^1.8.27"): {
-      output = await emitVueTscV1(vfs, srcFiles, originFiles, opts);
-      break;
-    }
-    // @ts-expect-error TODO: fix ts
-    case satisfies(version, "~v2.0.0"): {
-      output = await emitVueTscV2(vfs, srcFiles, originFiles, opts);
-      break;
-    }
-    default: {
-      output = await emitVueTscLatest(vfs, srcFiles, originFiles, opts);
-    }
-  }
-  return output;
-}
-const SFC_EXT_RE = /\.vue\.[cm]?[jt]s$/;
-function getFileMapping(vfs) {
-  const files = /* @__PURE__ */ Object.create(null);
-  for (const [srcPath] of vfs) {
-    if (SFC_EXT_RE.test(srcPath)) {
-      files[srcPath.replace(SFC_EXT_RE, ".vue")] = srcPath;
-    }
-  }
-  return files;
-}
-async function emitVueTscV1(vfs, inputFiles, originFiles, opts) {
-  const vueTsc = await import("vue-tsc").then((r) => r.default || r).catch(() => {
-  });
-  const ts = require("typescript");
-  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
-  const _tsSysWriteFile = ts.sys.writeFile;
-  ts.sys.writeFile = (filename, content) => {
-    vfs.set(filename, content);
-  };
-  const _tsSysReadFile = ts.sys.readFile;
-  ts.sys.readFile = (filename, encoding) => {
-    if (vfs.has(filename)) {
-      return vfs.get(filename);
-    }
-    return _tsSysReadFile(filename, encoding);
-  };
-  try {
-    const program = vueTsc.createProgram({
-      rootNames: inputFiles,
-      // @ts-expect-error TODO: fix ts
-      options: opts.typescript.compilerOptions,
-      host: tsHost
-    });
-    const result = program.emit();
-    const output = extractDeclarations(vfs, originFiles, opts);
-    augmentWithDiagnostics(result, output, tsHost, ts);
-    return output;
-  } finally {
-    ts.sys.writeFile = _tsSysWriteFile;
-    ts.sys.readFile = _tsSysReadFile;
-  }
-}
-async function emitVueTscV2(vfs, inputFiles, originFiles, opts) {
-  const { resolve: resolveModule } = await import("mlly");
-  const ts = await import("typescript").then((r) => r.default || r);
-  const vueTsc = await import("vue-tsc");
-  const requireFromVueTsc = createRequire(await resolveModule("vue-tsc"));
-  const vueLanguageCore = requireFromVueTsc("@vue/language-core");
-  const volarTs = requireFromVueTsc("@volar/typescript");
-  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
-  tsHost.writeFile = (filename, content) => {
-    vfs.set(filename, vueTsc.removeEmitGlobalTypes(content));
-  };
-  const _tsReadFile = tsHost.readFile.bind(tsHost);
-  tsHost.readFile = (filename) => {
-    if (vfs.has(filename)) {
-      return vfs.get(filename);
-    }
-    return _tsReadFile(filename);
-  };
-  const _tsFileExist = tsHost.fileExists.bind(tsHost);
-  tsHost.fileExists = (filename) => {
-    return vfs.has(filename) || _tsFileExist(filename);
-  };
-  const programOptions = {
-    rootNames: inputFiles,
-    // @ts-expect-error TODO: fix ts
-    options: opts.typescript.compilerOptions,
-    host: tsHost
-  };
-  const createProgram = volarTs.proxyCreateProgram(ts, ts.createProgram, (ts2, options) => {
-    const vueLanguagePlugin = vueLanguageCore.createVueLanguagePlugin(
-      ts2,
-      (id) => id,
-      () => "",
-      (fileName) => {
-        const fileMap = /* @__PURE__ */ new Set();
-        for (const vueFileName of options.rootNames.map((rootName) => normalize(rootName))) {
-          fileMap.add(vueFileName);
-        }
-        return fileMap.has(fileName);
-      },
-      options.options,
-      // @ts-expect-error TODO: fix ts
-      {}
-    );
-    return [vueLanguagePlugin];
-  });
-  const program = createProgram(programOptions);
-  const result = program.emit();
-  const output = extractDeclarations(vfs, originFiles, opts);
-  augmentWithDiagnostics(result, output, tsHost, ts);
-  return output;
-}
-async function emitVueTscLatest(vfs, inputFiles, originFiles, opts) {
-  const { resolve: resolveModule } = await import("mlly");
-  const ts = await import("typescript").then((r) => r.default || r);
-  const requireFromVueTsc = createRequire(await resolveModule("vue-tsc"));
-  const vueLanguageCore = requireFromVueTsc("@vue/language-core");
-  const volarTs = requireFromVueTsc("@volar/typescript");
-  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
-  tsHost.writeFile = (filename, content) => {
-    vfs.set(filename, content);
-  };
-  const _tsReadFile = tsHost.readFile.bind(tsHost);
-  tsHost.readFile = (filename) => {
-    if (vfs.has(filename)) {
-      return vfs.get(filename);
-    }
-    return _tsReadFile(filename);
-  };
-  const _tsFileExist = tsHost.fileExists.bind(tsHost);
-  tsHost.fileExists = (filename) => {
-    return vfs.has(filename) || _tsFileExist(filename);
-  };
-  const programOptions = {
-    rootNames: inputFiles,
-    // @ts-expect-error TODO: fix ts
-    options: opts.typescript.compilerOptions,
-    host: tsHost
-  };
-  const createProgram = volarTs.proxyCreateProgram(ts, ts.createProgram, (ts2, options) => {
-    const vueLanguagePlugin = vueLanguageCore.createVueLanguagePlugin(
-      ts2,
-      options.options,
-      // @ts-expect-error TODO: fix ts
-      vueLanguageCore.createParsedCommandLineByJson(ts2, ts2.sys, opts.rootDir, {}, void 0, true).vueOptions,
-      (id) => id
-    );
-    return [vueLanguagePlugin];
-  });
-  const program = createProgram(programOptions);
-  const result = program.emit();
-  const output = extractDeclarations(vfs, originFiles, opts);
-  augmentWithDiagnostics(result, output, tsHost, ts);
-  return output;
-}

package/bin/impl/build/providers/mkdist/mkdist-mod.d.ts

@@ -1,2 +0,0 @@
-import type { BuildContext } from "../../../types/mod.js";
-export declare function mkdistBuild(ctx: BuildContext): Promise<void>;

package/bin/impl/build/providers/mkdist/mkdist-mod.js

@@ -1,92 +0,0 @@
-import { dirname as pathDirname, relative } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { rmdir, symlink, warn } from "../utils.js";
-import { mkdist } from "./mkdist-impl/make.js";
-export async function mkdistBuild(ctx) {
-  const entries = ctx.options.entries.filter((e) => e.builder === "mkdist");
-  if (entries.length === 0) {
-    return;
-  }
-  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
-  let processedEntries = 0;
-  let totalWrittenFiles = 0;
-  let totalErrors = 0;
-  relinka("verbose", `Processing ${entries.length} mkdist entries...`);
-  for (const entry of entries) {
-    processedEntries++;
-    relinka("verbose", `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`);
-    const distDir = entry.outDir || entry.input;
-    if (ctx.options.transpileStub) {
-      await rmdir(distDir);
-      await symlink(entry.input, distDir);
-      continue;
-    }
-    let srcDir;
-    if (typeof entry.input === "string" && !entry.input.endsWith("/")) {
-      srcDir = ctx.options.isLib ? pathDirname(entry.input) : entry.input;
-      relinka(
-        "verbose",
-        `[mkdist] Using directory from file path: ${srcDir} (from: ${entry.input})`
-      );
-    } else {
-      srcDir = entry.input;
-      relinka("verbose", `[mkdist] Using directory directly: ${srcDir}`);
-    }
-    const mkdistOptions = {
-      cleanDist: false,
-      distDir,
-      rootDir: ctx.options.rootDir,
-      srcDir,
-      format: "esm",
-      ext: entry.ext || "js",
-      ...entry
-    };
-    relinka(
-      "verbose",
-      `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
-    );
-    await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
-    try {
-      const { result: output, duration } = await mkdist(mkdistOptions);
-      relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
-      totalWrittenFiles += output.writtenFiles.length;
-      ctx.buildEntries.push({
-        chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
-        path: distDir,
-        isLib: ctx.options.isLib
-      });
-      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
-      if (output.errors && output.errors.length > 0) {
-        totalErrors += output.errors.length;
-        for (const error of output.errors) {
-          warn(
-            ctx,
-            `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
-${error.errors.map((e) => `  - ${e}`).join("\n")}`
-          );
-        }
-      }
-    } catch (error) {
-      totalErrors++;
-      warn(
-        ctx,
-        `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  await ctx.hooks.callHook("mkdist:done", ctx);
-  if (entries.length > 0 && ctx.options.transpileWatch) {
-    relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
-  }
-  if (totalErrors > 0) {
-    relinka(
-      "warn",
-      `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
-    );
-  } else {
-    relinka(
-      "verbose",
-      `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
-    );
-  }
-}

package/bin/impl/build/providers/rollup/build.d.ts

@@ -1,2 +0,0 @@
-import type { BuildContext } from "../../../types/mod.js";
-export declare function rollupBuild(ctx: BuildContext): Promise<void>;

package/bin/impl/build/providers/rollup/build.js

@@ -1,100 +0,0 @@
-import { resolve } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { rollup } from "rollup";
-import dts from "rollup-plugin-dts";
-import { getRollupOptions } from "./config.js";
-import { fixCJSExportTypePlugin } from "./plugins/cjs.js";
-import { removeShebangPlugin } from "./plugins/shebang.js";
-import { rollupStub } from "./stub.js";
-import { getChunkFilename } from "./utils.js";
-import { rollupWatch } from "./watch.js";
-export async function rollupBuild(ctx) {
-  if (ctx.options.transpileStub) {
-    await rollupStub(ctx);
-    await ctx.hooks.callHook("rollup:done", ctx);
-    return;
-  }
-  const rollupOptions = getRollupOptions(ctx);
-  await ctx.hooks.callHook("rollup:options", ctx, rollupOptions);
-  if (Object.keys(rollupOptions.input).length === 0) {
-    await ctx.hooks.callHook("rollup:done", ctx);
-    return;
-  }
-  const buildResult = await rollup(rollupOptions);
-  await ctx.hooks.callHook("rollup:build", ctx, buildResult);
-  const allOutputOptions = rollupOptions.output;
-  for (const outputOptions of allOutputOptions) {
-    const { output } = await buildResult.write(outputOptions);
-    const chunkFileNames = /* @__PURE__ */ new Set();
-    const outputChunks = output.filter((e) => e.type === "chunk");
-    for (const entry of outputChunks) {
-      chunkFileNames.add(entry.fileName);
-      for (const id of entry.imports) {
-        ctx.usedImports.add(id);
-      }
-      if (entry.isEntry) {
-        ctx.buildEntries.push({
-          bytes: Buffer.byteLength(entry.code, "utf8"),
-          chunks: entry.imports.filter((i) => outputChunks.find((c) => c.fileName === i)),
-          exports: entry.exports,
-          modules: Object.entries(entry.modules).map(([id, mod]) => ({
-            bytes: mod.renderedLength,
-            id
-          })),
-          path: entry.fileName,
-          isLib: ctx.options.isLib
-        });
-      }
-    }
-    for (const chunkFileName of chunkFileNames) {
-      ctx.usedImports.delete(chunkFileName);
-    }
-  }
-  if (ctx.options.transpileWatch) {
-    rollupWatch(rollupOptions);
-    if (ctx.options.declaration && ctx.options.transpileWatch) {
-      relinka("warn", "`rollup` DTS builder does not support transpileWatch mode yet.");
-    }
-    return;
-  }
-  if (ctx.options.declaration) {
-    const plugins = [
-      dts(ctx.options.rollup.dts),
-      removeShebangPlugin(),
-      ctx.options.rollup.emitCJS && fixCJSExportTypePlugin(ctx)
-    ].filter(
-      (plugin) => (
-        /**
-         * Issue: #396
-         * rollup-plugin-dts conflicts with rollup-plugin-commonjs:
-         * https://github.com/Swatinem/rollup-plugin-dts#what-to-expect
-         */
-        !!plugin && (!("name" in plugin) || plugin.name !== "commonjs")
-      )
-    );
-    rollupOptions.plugins = plugins;
-    await ctx.hooks.callHook("rollup:dts:options", ctx, rollupOptions);
-    const typesBuild = await rollup(rollupOptions);
-    await ctx.hooks.callHook("rollup:dts:build", ctx, typesBuild);
-    if (ctx.options.rollup.emitCJS) {
-      await typesBuild.write({
-        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "d.cts"),
-        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
-        entryFileNames: "[name].d.cts"
-      });
-    }
-    await typesBuild.write({
-      chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "d.mts"),
-      dir: resolve(ctx.options.rootDir, ctx.options.outDir),
-      entryFileNames: "[name].d.mts"
-    });
-    if (ctx.options.declaration === true || ctx.options.declaration === "compatible") {
-      await typesBuild.write({
-        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "d.ts"),
-        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
-        entryFileNames: "[name].d.ts"
-      });
-    }
-  }
-  await ctx.hooks.callHook("rollup:done", ctx);
-}

package/bin/impl/build/providers/rollup/config.d.ts

@@ -1,2 +0,0 @@
-import type { BuildContext, RollupOptions } from "../../../types/mod.js";
-export declare function getRollupOptions(ctx: BuildContext): RollupOptions;

package/bin/impl/build/providers/rollup/config.js

@@ -1,112 +0,0 @@
-import { isAbsolute, resolve, resolveAlias } from "@reliverse/pathkit";
-import { parseNodeModulePath } from "mlly";
-import { arrayIncludes, getpkg, warn } from "../utils.js";
-import { cjsPlugin } from "./plugins/cjs.js";
-import { esbuild } from "./plugins/esbuild.js";
-import { JSONPlugin } from "./plugins/json.js";
-import { rawPlugin } from "./plugins/raw.js";
-import { shebangPlugin } from "./plugins/shebang.js";
-import { DEFAULT_EXTENSIONS, getChunkFilename, resolveAliases } from "./utils.js";
-const replaceModule = await import("@rollup/plugin-replace");
-const replace = replaceModule.default || replaceModule;
-const aliasModule = await import("@rollup/plugin-alias");
-const alias = aliasModule.default || aliasModule;
-const commonjsModule = await import("@rollup/plugin-commonjs");
-const commonjs = commonjsModule.default || commonjsModule;
-const nodeResolveModule = await import("@rollup/plugin-node-resolve");
-const nodeResolve = nodeResolveModule.nodeResolve || nodeResolveModule.default || nodeResolveModule;
-export function getRollupOptions(ctx) {
-  const _aliases = resolveAliases(ctx);
-  return {
-    external(originalId) {
-      const resolvedId = resolveAlias(originalId, _aliases);
-      const pkgName = parseNodeModulePath(resolvedId)?.name || parseNodeModulePath(originalId)?.name || getpkg(originalId);
-      if (arrayIncludes(ctx.options.externals, pkgName) || arrayIncludes(ctx.options.externals, originalId) || arrayIncludes(ctx.options.externals, resolvedId)) {
-        return true;
-      }
-      for (const id of [originalId, resolvedId]) {
-        if (id.startsWith(".") || isAbsolute(id) || /src[/\\]/.test(id) || ctx.pkg.name && id.startsWith(ctx.pkg.name)) {
-          return false;
-        }
-      }
-      if (ctx.options.rollup.inlineDependencies === true || Array.isArray(ctx.options.rollup.inlineDependencies) && (arrayIncludes(ctx.options.rollup.inlineDependencies, pkgName) || arrayIncludes(ctx.options.rollup.inlineDependencies, originalId) || arrayIncludes(ctx.options.rollup.inlineDependencies, resolvedId))) {
-        return false;
-      }
-      warn(ctx, `Implicitly bundling "${originalId}"`);
-      return false;
-    },
-    input: Object.fromEntries(
-      ctx.options.entries.filter((entry) => entry.builder === "rollup").map((entry) => [entry.name, resolve(ctx.options.rootDir, entry.input)])
-    ),
-    onwarn(warning, rollupWarn) {
-      if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
-        rollupWarn(warning);
-      }
-    },
-    output: [
-      ctx.options.rollup.emitCJS && {
-        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "cjs"),
-        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
-        entryFileNames: "[name].cjs",
-        exports: "auto",
-        externalLiveBindings: false,
-        format: "cjs",
-        freeze: false,
-        generatedCode: { constBindings: true },
-        interop: "compat",
-        sourcemap: ctx.options.transpileSourcemap,
-        ...ctx.options.rollup.output
-      },
-      {
-        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "mjs"),
-        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
-        entryFileNames: "[name].mjs",
-        exports: "auto",
-        externalLiveBindings: false,
-        format: "esm",
-        freeze: false,
-        generatedCode: { constBindings: true },
-        sourcemap: ctx.options.transpileSourcemap,
-        ...ctx.options.rollup.output
-      }
-    ].filter(Boolean),
-    plugins: [
-      ctx.options.rollup.replace && replace({
-        ...ctx.options.rollup.replace,
-        values: {
-          ...ctx.options.replace,
-          ...ctx.options.rollup.replace.values
-        }
-      }),
-      ctx.options.rollup.alias && alias({
-        ...ctx.options.rollup.alias,
-        entries: _aliases
-      }),
-      ctx.options.rollup.resolve && nodeResolve({
-        exportConditions: ["production"],
-        extensions: DEFAULT_EXTENSIONS,
-        ...ctx.options.rollup.resolve
-      }),
-      ctx.options.rollup.json && JSONPlugin({
-        ...ctx.options.rollup.json
-      }),
-      shebangPlugin(),
-      ctx.options.rollup.esbuild && esbuild({
-        sourcemap: ctx.options.transpileSourcemap,
-        ...ctx.options.rollup.esbuild
-      }),
-      ctx.options.rollup.commonjs && commonjs({
-        extensions: DEFAULT_EXTENSIONS,
-        ...ctx.options.rollup.commonjs
-      }),
-      ctx.options.rollup.preserveDynamicImports && {
-        name: "dler=preserve-dynamic-imports",
-        renderDynamicImport() {
-          return { left: "import(", right: ")" };
-        }
-      },
-      ctx.options.rollup.cjsBridge && cjsPlugin(),
-      rawPlugin()
-    ].filter((p) => !!p)
-  };
-}

package/bin/impl/build/providers/rollup/plugins/cjs.d.ts

@@ -1,4 +0,0 @@
-import type { Plugin } from "rollup";
-import type { BuildContext } from "../../../../types/mod.js";
-export declare function cjsPlugin(): Plugin;
-export declare function fixCJSExportTypePlugin(ctx: BuildContext): Plugin;

package/bin/impl/build/providers/rollup/plugins/cjs.js

@@ -1,47 +0,0 @@
-import { FixDtsDefaultCjsExportsPlugin } from "fix-dts-default-cjs-exports/rollup";
-import MagicString from "magic-string";
-import { findStaticImports } from "mlly";
-export function cjsPlugin() {
-  return {
-    name: "dler-cjs",
-    renderChunk(code, _chunk, opts) {
-      if (opts.format === "es") {
-        const result = CJSToESM(code);
-        return result || null;
-      }
-      return null;
-    }
-  };
-}
-export function fixCJSExportTypePlugin(ctx) {
-  const regexp = ctx.options.declaration === "node16" ? /\.d\.cts$/ : /\.d\.c?ts$/;
-  return FixDtsDefaultCjsExportsPlugin({
-    matcher: (info) => {
-      return info.type === "chunk" && info.exports?.length > 0 && info.exports.includes("default") && regexp.test(info.fileName) && info.isEntry;
-    },
-    warn: (msg) => ctx.warnings.add(msg)
-  });
-}
-const CJSyntaxRe = /__filename|__dirname|require\(|require\.resolve\(/;
-const CJSShim = `
-// -- dler CommonJS Shims --
-import __cjs_url__ from 'url';
-import __cjs_path__ from 'path';
-import __cjs_mod__ from 'module';
-const __filename = __cjs_url__.fileURLToPath(import.meta.url);
-const __dirname = __cjs_path__.dirname(__filename);
-const require = __cjs_mod__.createRequire(import.meta.url);
-`;
-function CJSToESM(code) {
-  if (code.includes(CJSShim) || !CJSyntaxRe.test(code)) {
-    return null;
-  }
-  const lastESMImport = findStaticImports(code).pop();
-  const indexToAppend = lastESMImport ? lastESMImport.end : 0;
-  const s = new MagicString(code);
-  s.appendRight(indexToAppend, CJSShim);
-  return {
-    code: s.toString(),
-    map: s.generateMap({ hires: true })
-  };
-}

package/bin/impl/build/providers/rollup/plugins/esbuild.d.ts

@@ -1,3 +0,0 @@
-import type { Plugin } from "rollup";
-import type { EsbuildOptions } from "../../../../types/mod.js";
-export declare function esbuild(options: EsbuildOptions): Plugin;