pkgbld 1.36.0 → 2.1.0

package/dist/index.mjs

@@ -1,1626 +0,0 @@
-import '@niceties/draftlog-appender';
-import { createLogger } from '@niceties/logger';
-import { rollup } from 'rollup';
-import fs, { readFile, access, stat, constants, writeFile, rm, readdir, mkdir, rename } from 'node:fs/promises';
-import path, { dirname, join } from 'node:path';
-import { cli, command } from 'cleye';
-import refiner from '@slimlib/refine-partition';
-import camelCase from 'lodash/camelCase.js';
-import kleur from 'kleur';
-import { fileURLToPath } from 'node:url';
-import cloneDeep from 'lodash/cloneDeep.js';
-import isEqual from 'lodash/isEqual.js';
-
-async function createSubpackages(inputs, config) {
-    for (const input of inputs) {
-        const basename = path.basename(input, path.extname(input));
-        if (basename !== 'index') {
-            const pkg = {
-                type: 'module',
-                types: `../${config.dir}/${basename}.d.ts`,
-                main: `../${config.dir}/${basename}.mjs`
-            };
-            await fs.mkdir(basename, { recursive: true });
-            await fs.writeFile(`${basename}/package.json`, JSON.stringify(pkg, null, 2));
-        }
-    }
-}
-
-function CommaSeparatedString(value) {
-    return value.split(',').map((arg) => arg.trim());
-}
-function CommaSeparatedStringOrBoolean(value) {
-    if (typeof value === 'boolean') {
-        return value;
-    }
-    // TODO check how we get array here
-    if (Array.isArray(value) && value.length === 0) {
-        return true;
-    }
-    return CommaSeparatedString(value);
-}
-const cliFlagsDefaults = {
-    formats: ['es', 'cjs'],
-    umd: [],
-    compress: ['umd'],
-    sourcemaps: ['umd'],
-    preprocess: [],
-    dest: 'dist',
-    src: 'src',
-    bin: undefined,
-    includeExternals: false,
-    eject: false,
-    noTsConfig: false,
-    noUpdatePackageJson: false,
-    commonjsPattern: '[name].cjs',
-    esmPattern: '[name].mjs',
-    umdPattern: '[name].umd.js',
-    formatPackageJson: false,
-    noSubpackages: false,
-};
-const cliFlags = {
-    umd: {
-        type: CommaSeparatedString,
-        description: 'Package subpath exports in UMD format',
-        default: cliFlagsDefaults.umd,
-    },
-    compress: {
-        type: CommaSeparatedString,
-        description: 'Compress formats using terser',
-        default: cliFlagsDefaults.compress,
-    },
-    sourcemaps: {
-        type: CommaSeparatedString,
-        description: 'Emit sourcemaps for the specified formats',
-        default: cliFlagsDefaults.sourcemaps,
-    },
-    formats: {
-        type: CommaSeparatedString,
-        description: 'Formats to emit',
-        default: cliFlagsDefaults.formats,
-    },
-    preprocess: {
-        type: CommaSeparatedString,
-        description: 'Preprocess entry points / subpath exports',
-        default: cliFlagsDefaults.preprocess,
-    },
-    dest: {
-        type: String,
-        description: 'Output directory',
-        default: cliFlagsDefaults.dest,
-    },
-    src: {
-        type: String,
-        description: 'Source directory',
-        default: cliFlagsDefaults.src,
-    },
-    bin: {
-        type: CommaSeparatedString,
-        description: 'Executable files',
-        default: cliFlagsDefaults.bin,
-    },
-    includeExternals: {
-        type: CommaSeparatedStringOrBoolean,
-        description: 'Include all/specified externals into the result bundle(s)',
-        default: cliFlagsDefaults.includeExternals,
-    },
-    eject: {
-        type: Boolean,
-        description: 'Eject config',
-        default: cliFlagsDefaults.eject,
-    },
-    noTsConfig: {
-        type: Boolean,
-        description: 'Do not create / update tsconfig.json',
-        default: cliFlagsDefaults.noTsConfig,
-    },
-    noUpdatePackageJson: {
-        type: Boolean,
-        description: 'Do not create / update package.json',
-        default: cliFlagsDefaults.noUpdatePackageJson,
-    },
-    commonjsPattern: {
-        type: String,
-        description: 'CommonJS output file name pattern',
-        default: cliFlagsDefaults.commonjsPattern,
-    },
-    esmPattern: {
-        type: String,
-        description: 'ES output file name pattern',
-        default: cliFlagsDefaults.esmPattern,
-    },
-    umdPattern: {
-        type: String,
-        description: 'UMD output file name pattern',
-        default: cliFlagsDefaults.umdPattern,
-    },
-    formatPackageJson: {
-        type: Boolean,
-        description: 'Format package.json',
-        default: cliFlagsDefaults.formatPackageJson,
-    },
-    noPack: {
-        type: Boolean,
-        description: 'Do not pack',
-        default: false,
-    },
-    noExports: {
-        type: Boolean,
-        description: 'Do not add exports field to package.json',
-        default: false,
-    },
-    noClean: {
-        type: Boolean,
-        description: 'Do not clean the output directory',
-        default: false,
-    },
-    noBundle: {
-        type: Boolean,
-        description: 'Do not bundle',
-        default: false,
-    },
-    removeLegalComments: {
-        type: Boolean,
-        description: 'Remove legal comments',
-        default: false,
-    },
-    noSubpackages: {
-        type: Boolean,
-        description: 'Do not create subpackage directories with package.json files',
-        default: cliFlagsDefaults.noSubpackages,
-    },
-};
-const packageJsonFieldsOrder = new Set([
-    'private',
-    'type',
-    'version',
-    'name',
-    'scope', // custom
-    'description',
-    'license',
-    'author',
-    'contributors',
-    'funding',
-    'bin',
-    'main',
-    'browser',
-    'unpkg',
-    'module',
-    'svelte',
-    'exports',
-    'imports',
-    'types',
-    'typings',
-    'typesVersions', // non standard but required for typescript with resolution other than nodenext
-    'files',
-    'packageManager',
-    'sideEffects',
-    'engines',
-    'os',
-    'cpu',
-    'man',
-    'directories',
-    'repository',
-    'bugs',
-    'homepage',
-    'readme',
-    'keywords',
-    'scripts',
-    'config',
-    'dependencies',
-    'devDependencies',
-    'peerDependencies',
-    'peerDependenciesMeta',
-    'bundleDependencies',
-    'bundledDependencies',
-    'optionalDependencies',
-    'overrides',
-    'publishConfig',
-    'workspaces',
-]);
-function processPackageJson(pkg, needTreatment, treatKey) {
-    const newPkg = {};
-    for (const key of packageJsonFieldsOrder) {
-        if (needTreatment(key)) {
-            newPkg[key] = treatKey(key);
-        }
-    }
-    for (const key in pkg) {
-        if (!packageJsonFieldsOrder.has(key)) {
-            newPkg[key] = pkg[key];
-        }
-    }
-    return newPkg;
-}
-function toFormattedJson(json) {
-    return `${JSON.stringify(json, null, 2)}\n`;
-}
-
-function FlattenParam(value) {
-    if (typeof value === 'boolean') {
-        return value; // false
-    }
-    if (value === '') {
-        return true; // means auto
-    }
-    return value; // string
-}
-function getCliOptions(plugins, pkg) {
-    const cliOptions = cli({
-        name: 'pkgbld',
-        version: pkg.version ?? '<unknown>',
-        flags: cliFlags,
-        commands: [
-            command({
-                name: 'prune',
-                description: 'prune devDependencies and redundant scripts from package.json',
-                flags: {
-                    profile: {
-                        type: String,
-                        description: 'profile to use',
-                        default: 'library'
-                    },
-                    flatten: {
-                        type: FlattenParam,
-                        description: 'flatten package files',
-                        default: false
-                    },
-                    removeSourcemaps: {
-                        type: Boolean,
-                        description: 'remove sourcemaps',
-                        default: false
-                    },
-                    optimizeFiles: {
-                        type: Boolean,
-                        description: 'optimize files array',
-                        default: true
-                    }
-                }
-            })
-        ]
-    });
-    if (cliOptions.command === 'prune') {
-        return {
-            kind: 'prune',
-            profile: cliOptions.flags.profile,
-            flatten: cliOptions.flags.flatten,
-            removeSourcemaps: cliOptions.flags.removeSourcemaps,
-            optimizeFiles: cliOptions.flags.optimizeFiles
-        };
-    }
-    const flags = cliOptions.flags;
-    const options = {
-        kind: 'build',
-        umdInputs: flags.umd,
-        compressFormats: flags.compress,
-        sourcemapFormats: flags.sourcemaps,
-        formats: flags.formats,
-        formatsOverridden: flags.formats !== cliFlagsDefaults.formats,
-        preprocess: flags.preprocess,
-        dir: flags.dest,
-        sourceDir: flags.src,
-        bin: flags.bin,
-        includeExternals: flags.includeExternals,
-        eject: flags.eject,
-        noTsConfig: flags.noTsConfig,
-        noUpdatePackageJson: flags.noUpdatePackageJson,
-        commonjsPattern: flags.commonjsPattern,
-        esPattern: flags.esmPattern,
-        umdPattern: flags.umdPattern,
-        formatPackageJson: flags.formatPackageJson,
-        noPack: flags.noPack,
-        noExports: flags.noExports,
-        noClean: flags.noClean,
-        noBundle: flags.noBundle,
-        removeLegalComments: flags.removeLegalComments,
-        noSubpackages: flags.noSubpackages
-    };
-    for (const plugin of plugins) {
-        plugin.options?.(flags, options);
-    }
-    return options;
-}
-
-async function getJson(fileName) {
-    const pkgPath = path.resolve(fileName);
-    const buffer = await fs.readFile(pkgPath);
-    return [pkgPath, JSON.parse(buffer.toString())];
-}
-
-const Priority = {
-    preprocess: 1000,
-    cleanup: 1000,
-    externals: 2000,
-    resolve: 3000,
-    commonjs: 4000,
-    transpile: 6000,
-    compress: 10000,
-    finalize: 20000
-};
-
-async function clean (provider, config) {
-    if (config.noClean) {
-        return;
-    }
-    const pluginClean = await provider.import('@rollup-extras/plugin-clean');
-    const pluginInstance = pluginClean();
-    provider.provide(pluginFactory, Priority.cleanup, { outputPlugin: true });
-    let firstPluginInstance = true;
-    function pluginFactory() {
-        const result = firstPluginInstance ? pluginInstance : pluginInstance.api.addInstance();
-        firstPluginInstance = false;
-        return result;
-    }
-}
-
-async function commonjs (provider) {
-    const pluginCommonjs = await provider.import('@rollup/plugin-commonjs');
-    provider.provide(() => pluginCommonjs(), Priority.commonjs);
-}
-
-async function externals (provider, config, inputs, inputsExt) {
-    if (config.includeExternals === true) {
-        return;
-    }
-    const pluginExternals = await provider.import('@rollup-extras/plugin-externals');
-    const allowGenericUmd = config.umdInputs.length === 1 && inputs.length === 1;
-    if (config.formats.length > 0) {
-        const format = (allowGenericUmd ? undefined : config.formats.filter(format => format !== 'umd'));
-        provider.provide(() => pluginExternals(config.includeExternals === false
-            ? {}
-            : (id, external, importer) => includeExternals(importer, external, id, config)), Priority.externals, { format });
-        // for eject config
-        provider.globalImport('path', 'path');
-        provider.globalSetup(includeExternals);
-    }
-    if (!allowGenericUmd && config.umdInputs.length > 0) {
-        const curry = (await provider.import('lodash/curry.js'));
-        for (const currentInput of config.umdInputs) {
-            const isExternal = curry((currentInput, id, external, importer) => includeExternals(importer, external, id, config) || isExternalInput(currentInput, inputs, inputsExt, id, config))(currentInput);
-            provider.provide(() => pluginExternals(isExternal), Priority.externals, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
-        }
-        // for eject config
-        if (config.formats.length === 0) {
-            provider.globalImport('path', 'path');
-            provider.globalSetup(includeExternals);
-        }
-        provider.globalSetup(isExternalInput);
-    }
-}
-function includeExternals(importer, external, id, config) {
-    if (config.includeExternals === false)
-        return external;
-    if (!external)
-        return false;
-    const internals = config.includeExternals;
-    if (internals.includes(id) || internals.some(internal => id.includes(internal))) {
-        return false;
-    }
-    return true;
-}
-function isExternalInput(currentInput, inputs, inputsExt, id, config) {
-    const normalizedPath = path.isAbsolute(currentInput)
-        ? `./${path.relative(process.cwd(), `${currentInput}.${inputsExt.get(currentInput)}`)}`
-        : `./${path.join(config.sourceDir, `${currentInput}.${inputsExt.get(currentInput)}`)}`;
-    const normalizedId = path.isAbsolute(id) ? `./${path.relative(process.cwd(), id)}` : id;
-    return normalizedPath !== normalizedId && inputs.includes(normalizedPath);
-}
-
-async function preprocess (provider, config, inputs, inputsExt) {
-    if (config.preprocess.length > 0) {
-        const pluginPreprocess = await provider.import('rollup-plugin-preprocess');
-        const include = config.preprocess.map(name => `${config.sourceDir}/${name}.${inputsExt.get(name)}`);
-        for (const format of config.formats) {
-            if (format !== 'umd') {
-                provider.provide(() => pluginPreprocess.default({ include, context: { [format]: true } }), Priority.preprocess, { format });
-            }
-            else {
-                for (const currentInput of config.umdInputs) {
-                    provider.provide(() => pluginPreprocess.default({ include, context: { umd: true } }), Priority.preprocess, { format, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
-                }
-            }
-        }
-    }
-}
-
-async function resolve (provider) {
-    const pluginResolve = await provider.import('@rollup/plugin-node-resolve');
-    provider.provide(() => pluginResolve(), Priority.resolve);
-}
-
-async function terser (provider, config, inputs, inputsExt) {
-    const filteredFormats = config.compressFormats.filter(format => config.formats.includes(format));
-    if (filteredFormats.length > 0) {
-        const pluginTerser = await provider.import('@rollup/plugin-terser');
-        const options = {
-            mangle: {
-                properties: {
-                    regex: /_$/
-                }
-            }
-        };
-        if (config.removeLegalComments) {
-            options.output = {
-                comments: false,
-            };
-        }
-        if (filteredFormats.length > 0) {
-            for (const format of filteredFormats) {
-                if (format !== 'umd') {
-                    provider.provide(() => pluginTerser(options), Priority.compress, { format, outputPlugin: true });
-                }
-                else {
-                    for (const currentInput of config.umdInputs) {
-                        provider.provide(() => pluginTerser(options), Priority.compress, { format, outputPlugin: true, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
-                    }
-                }
-            }
-        }
-    }
-}
-
-async function typescript (provider, config, inputs) {
-    const typescriptInputs = inputs.filter(input => input.endsWith('.ts') || input.endsWith('.tsx'));
-    if (typescriptInputs.length > 0) {
-        const pluginTypescript = await provider.import('rollup-plugin-typescript2');
-        provider.provide(() => pluginTypescript(), Priority.transpile, typescriptInputs.length === inputs.length ? undefined : { inputs: typescriptInputs });
-    }
-}
-
-async function binify (provider, config) {
-    if (config.bin != null && config.bin.length > 0) {
-        const pluginBinify = await provider.import('@rollup-extras/plugin-binify');
-        provider.provide(() => pluginBinify({
-            filter: (item) => item.type === 'chunk' && item.isEntry && config.bin.some(input => input === `./${config.dir}/${item.fileName}`)
-        }), Priority.finalize, { outputPlugin: true, format: 'cjs' });
-    }
-}
-
-async function json (provider) {
-    const pluginJson = await provider.import('@rollup/plugin-json');
-    provider.provide(() => pluginJson(), Priority.preprocess);
-}
-
-const plugins = [
-    clean,
-    commonjs,
-    externals,
-    preprocess,
-    resolve,
-    terser,
-    typescript,
-    binify,
-    json
-];
-const noop = () => undefined;
-function createProvider(preimportMap) {
-    const plugins = [];
-    return [{
-            provide: (plugin, priority, options) => {
-                plugins.push({ priority, plugin, format: options?.format, inputs: options?.inputs, outputPlugin: options?.outputPlugin });
-            },
-            import: async (name, exportName) => {
-                const result = preimportMap.has(name) ? await preimportMap.get(name) : await import(name);
-                return result[exportName ?? 'default'];
-            },
-            globalImport: noop,
-            globalSetup: noop
-        }, plugins];
-}
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-function getHelpers(pkgName) {
-    function getGlobalName(anInput) {
-        return camelCase(path.join(pkgName, path.basename(anInput, path.extname(anInput)) !== 'index' ? path.basename(anInput, path.extname(anInput)) : ''));
-    }
-    function getExternalGlobalName(id) {
-        if (path.isAbsolute(id)) {
-            return getGlobalName(path.relative(__dirname, id));
-        }
-        return camelCase(id);
-    }
-    return {
-        getGlobalName,
-        getExternalGlobalName
-    };
-}
-function toArray(object) {
-    if (Array.isArray(object)) {
-        return object;
-    }
-    if (object == null) {
-        return [];
-    }
-    return [object];
-}
-function formatInput(input) {
-    return (Array.isArray(input) ? input : [input ?? '']).map(item => kleur.magenta(path.basename(item, path.extname(item)))).join(', ');
-}
-function formatOutput(output, field) {
-    //? can we avoid it
-    if (output == null) {
-        return '';
-    }
-    return (Array.isArray(output) ? output : [output ?? '']).map(item => kleur.cyan(item[field])).join(', ');
-}
-function getTimeDiff(starting) {
-    const diff = Date.now() - starting;
-    return diff >= 1000 ? `${(diff / 1000).toFixed(1)}s` : `${diff}ms`;
-}
-const areSetsEqual = (a, b) => a.size === b.size ? [...a].every(value => b.has(value)) : false;
-function formatPackageJson(pkg) {
-    return processPackageJson(pkg, key => key in pkg, key => pkg[key]);
-}
-async function isExists(file) {
-    try {
-        await access(file);
-    }
-    catch (e) {
-        if (typeof e === 'object' && e != null && 'code' in e && e.code === 'ENOENT') {
-            return false;
-        }
-        throw e;
-    }
-    return file;
-}
-// it is borrowed from vite logic, basically the same but simplified
-// without recursion and fully async
-async function isReadable(file) {
-    try {
-        await stat(file);
-    }
-    catch {
-        return false;
-    }
-    try {
-        await access(file, constants.R_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function hasFile(root, file) {
-    const path = join(root, file);
-    return isExists(path);
-}
-async function hasWorkspacePackageJson(root) {
-    const path = join(root, 'package.json');
-    if (!await isReadable(path)) {
-        return false;
-    }
-    try {
-        const content = (JSON.parse(await readFile(path, 'utf-8')) || {});
-        return !!content.workspaces;
-    }
-    catch {
-        return false;
-    }
-}
-async function searchForPackageRoot(current) {
-    const root = current;
-    let dir = current;
-    while (dir) {
-        if (await hasFile(dir, 'package.json'))
-            return dir;
-        const parentDir = dirname(dir);
-        if (parentDir === dir)
-            break; // Reached the filesystem root
-        dir = parentDir;
-    }
-    return root;
-}
-async function searchForWorkspaceRoot(current) {
-    const root = await searchForPackageRoot(current);
-    let dir = current;
-    while (dir) {
-        if (await hasFile(dir, 'pnpm-workspace.yaml'))
-            return dir;
-        if (await hasWorkspacePackageJson(dir))
-            return dir;
-        const parentDir = dirname(dir);
-        if (parentDir === dir)
-            break; // Reached the filesystem root
-        dir = parentDir;
-    }
-    return root;
-}
-
-async function getRollupConfigs([provider, plugins$1], inputs, inputsExt, config, helpers, externalPlugins) {
-    const factoryInProgress = [];
-    const fileNamePatterns = {
-        'es': config.esPattern,
-        'cjs': config.commonjsPattern,
-        'umd': config.umdPattern
-    };
-    for (const factory of plugins) {
-        factoryInProgress.push(factory(provider, config, inputs, inputsExt));
-    }
-    for (const ePlugin of externalPlugins) {
-        if (ePlugin.providePlugins) {
-            factoryInProgress.push(ePlugin.providePlugins(provider, config, inputs, inputsExt));
-        }
-    }
-    await Promise.all(factoryInProgress);
-    const expandInputs = new Set;
-    for (const plugin of plugins$1) {
-        if (plugin.format && plugin.inputs?.length && !plugin.outputPlugin) {
-            for (const format of toArray(plugin.format)) {
-                expandInputs.add(format);
-            }
-        }
-    }
-    const refineNext = refiner();
-    refineNext(doExpandInputs(toArray(config.formats)));
-    for (const plugin of plugins$1) {
-        if (plugin.format && !plugin.outputPlugin) {
-            const formats = toArray(plugin.format);
-            if (!plugin.inputs || plugin.inputs.length === 0) {
-                refineNext(doExpandInputs(formats));
-            }
-            else if (inputs.length === 1) {
-                refineNext(formats);
-            }
-            else {
-                const expanded = [];
-                for (const format of formats) {
-                    for (const input of plugin.inputs) {
-                        expanded.push(`${format}.${input}`);
-                    }
-                }
-                refineNext(expanded);
-            }
-        }
-    }
-    const refined = refineNext();
-    const partitions = [];
-    for (const partition of refined) {
-        const result = [];
-        for (const format of partition) {
-            if (format.includes('.')) {
-                const [, realFormat, input] = format.split(/(.*?)\.(.*)/gm);
-                result.push({ format: realFormat, input });
-            }
-            else {
-                result.push({ format });
-            }
-        }
-        const mapFormatInputs = new Map;
-        const formatsWithoutInputs = new Set;
-        for (const { format, input } of result) {
-            if (input) {
-                if (mapFormatInputs.has(format)) {
-                    // biome-ignore lint/style/noNonNullAssertion: <explanation>
-                    mapFormatInputs.get(format).add(input);
-                }
-                else {
-                    mapFormatInputs.set(format, new Set([input]));
-                }
-            }
-            else {
-                formatsWithoutInputs.add(format);
-            }
-        }
-        for (const format of formatsWithoutInputs) {
-            if (mapFormatInputs.has(format)) {
-                throw new Error(`${format} is both used with inputs and without in plugins configuration and was not expanded / handled correctly. Please file an issue for pkgbld.`);
-            }
-            mapFormatInputs.set(format, new Set(inputs));
-        }
-        let prevInputs;
-        for (const inputs of mapFormatInputs.values()) {
-            if (prevInputs) {
-                if (!areSetsEqual(inputs, prevInputs)) {
-                    throw new Error(`unbalanced inputs for partition: ${JSON.stringify(partition)}`);
-                }
-            }
-            prevInputs = inputs;
-        }
-        partitions.push({ formats: [...mapFormatInputs.keys()], inputs: [...prevInputs] });
-    }
-    return partitions.map(({ formats, inputs }) => {
-        return {
-            input: inputs,
-            output: formats.map(format => ({
-                format,
-                dir: config.dir,
-                entryFileNames: fileNamePatterns[format],
-                plugins: getPlugins([format], inputs, true),
-                sourcemap: config.sourcemapFormats.includes(format),
-                // this requires more work
-                // preserveModules: true,
-                // preserveModulesRoot: config.sourceDir,
-                ...getExtraOutputSettings(format, inputs)
-            })),
-            plugins: getPlugins(formats, inputs, false)
-        };
-    });
-    function getExtraOutputSettings(format, inputs) {
-        let result = {};
-        switch (format) {
-            case 'cjs':
-            case 'es':
-                result = { chunkFileNames: fileNamePatterns[format] };
-                break;
-            case 'umd':
-                if (inputs.length <= 0) {
-                    break;
-                }
-                if (inputs.length > 1) {
-                    throw new Error(`Cannot produce global name for multiple umd inputs in one output: ${inputs}`);
-                }
-                result = {
-                    name: helpers.getGlobalName(inputs.join('_')),
-                    globals: helpers.getExternalGlobalName,
-                };
-                break;
-        }
-        for (const ePlugin of externalPlugins) {
-            if (ePlugin.getExtraOutputSettings) {
-                Object.assign(result, ePlugin.getExtraOutputSettings(format, inputs));
-            }
-        }
-        return result;
-    }
-    function getPlugins(formats, inputs, outputPlugin) {
-        const filteredPlugins = [];
-        for (const plugin of plugins$1) {
-            if ((!!plugin.outputPlugin) === outputPlugin) {
-                if ((!plugin.format || toArray(plugin.format).some(format => formats.includes(format)))
-                    && (!plugin.inputs || plugin.inputs.every(input => inputs.includes(input)))) {
-                    filteredPlugins.push({
-                        instance: plugin.plugin(),
-                        priority: plugin.priority
-                    });
-                }
-            }
-        }
-        filteredPlugins.sort((a, b) => a.priority - b.priority);
-        return filteredPlugins.map(plugin => plugin.instance);
-    }
-    function doExpandInputs(formats) {
-        if (inputs.length === 1) {
-            return formats;
-        }
-        const expanded = [];
-        for (const format of formats) {
-            if (expandInputs.has(format)) {
-                if (format !== 'umd') {
-                    for (const input of inputs) {
-                        expanded.push(`${format}.${input}`);
-                    }
-                }
-                else {
-                    for (const input of config.umdInputs) {
-                        expanded.push(`${format}../${config.sourceDir}/${input}.${inputsExt.get(input)}`);
-                    }
-                }
-            }
-            else {
-                expanded.push(format);
-            }
-        }
-        return expanded;
-    }
-}
-
-const mainLoggerText = (sourceDir, dir, configsCount, startingTime, finishedCount = 0) => (final = false) => `${sourceDir} → ${dir} ${final ? configsCount : finishedCount++} / ${configsCount}${final ? (` in ${getTimeDiff(startingTime)}`) : ''}`;
-
-const emptySet = new Set;
-const sourceFileSuffixes = ['ts', 'tsx', 'js', 'jsx', 'cjs', 'mjs']; // svelte, vue, etc. are not supported yet
-async function processPackage(pkg, config, plugins, tsConfig) {
-    const typingsFilePattern = '[name].d.ts';
-    const indexId = 'index';
-    const typesVersionsLastFields = new Set(['*']);
-    // check if declarations enabled
-    const isDeclarations = typeof tsConfig === 'object'
-        && tsConfig != null && 'compilerOptions' in tsConfig
-        && typeof tsConfig.compilerOptions === 'object' && tsConfig.compilerOptions !== null
-        && 'declaration' in tsConfig.compilerOptions && tsConfig.compilerOptions.declaration === true;
-    const inputs = [];
-    const inputsExt = new Map;
-    const logger = createLogger();
-    const allowEsm = (config.formatsOverridden && config.formats.includes('es') || !config.formatsOverridden);
-    const allowCjs = (config.formatsOverridden && config.formats.includes('cjs') || !config.formatsOverridden);
-    const allowUmd = (config.formatsOverridden && config.formats.includes('umd') || !config.formatsOverridden || config.umdInputs);
-    if (typeof pkg !== 'object' || Array.isArray(pkg) || pkg == null) {
-        logger.finish('expecting object on top level of package.json', 3 /* LogLevel.error */);
-        process.exit(-1);
-    }
-    if (typeof pkg.name !== 'string' && config.umdInputs.length > 0) {
-        logger.finish('expecting name to be a string in package.json', 3 /* LogLevel.error */);
-        process.exit(-1);
-    }
-    if (!Array.isArray(pkg.files)) {
-        pkg.files = [];
-    }
-    if (!pkg.files.includes(config.dir)) {
-        pkg.files.push(config.dir);
-    }
-    if (typeof pkg.scripts !== 'object' && pkg.scripts !== null) {
-        pkg.scripts = {};
-    }
-    if (!config.noPack && !('prepack' in pkg.scripts)) {
-        const binary = typeof pkg.scripts.build === 'string' && pkg.scripts.build?.startsWith('pkgbld-internal') ? 'pkgbld-internal' : 'pkgbld';
-        pkg.scripts.prepack = `${binary} prune`;
-    }
-    if (allowEsm && !allowCjs && typeof pkg.type !== 'string') {
-        pkg.type = 'module';
-    }
-    const exportsFields = new Set([
-        'types',
-        'svelte',
-        pkg.type === 'module' ? 'require' : 'import',
-        pkg.type === 'module' ? 'import' : 'require',
-        'default'
-    ]);
-    if (typeof pkg.typings === 'string') {
-        pkg.typings = undefined;
-    }
-    if (isDeclarations) {
-        pkg.types = `./${config.dir}/${patternToName(typingsFilePattern, 'index')}`;
-    }
-    if (allowUmd && typeof pkg.umd === 'string') {
-        pkg.umd = `./${config.dir}/${patternToName(config.umdPattern, indexId)}`;
-        if (!config.umdInputs.includes(indexId)) {
-            config.umdInputs.push(indexId);
-        }
-    }
-    if (allowCjs) {
-        pkg.main = `./${config.dir}/${patternToName(config.commonjsPattern, indexId)}`;
-    }
-    if (allowEsm && !allowCjs) {
-        pkg.main = `./${config.dir}/${patternToName(config.esPattern, indexId)}`;
-    }
-    if (allowCjs && allowEsm && typeof pkg.module !== 'string') {
-        pkg.module = `./${config.dir}/${patternToName(config.esPattern, indexId)}`;
-    }
-    if (allowUmd && config.umdInputs.includes(indexId)) {
-        pkg.unpkg = `./${config.dir}/${patternToName(config.umdPattern, indexId)}`;
-    }
-    if (isDeclarations) {
-        if (typeof pkg.typesVersions !== 'object' && pkg.typesVersions !== null) {
-            pkg.typesVersions = {};
-        }
-        if (typeof pkg.typesVersions['*'] !== 'object' && pkg.typesVersions['*'] !== null) {
-            pkg.typesVersions['*'] = {};
-        }
-    }
-    if (!config.noExports) {
-        if (typeof pkg.exports !== 'object' && pkg.exports !== null) {
-            pkg.exports = {};
-        }
-        if (pkg.exports['.'] == null) {
-            pkg.exports['.'] = {};
-        }
-        pkg.exports['./package.json'] = './package.json';
-        if (allowCjs && pkg.main !== pkg.exports['.'].require) {
-            pkg.exports['.'].require = pkg.main;
-        }
-        if (pkg.module !== pkg.exports['.']?.default) {
-            pkg.exports['.'].default = pkg.module;
-        }
-        for (const id in pkg.exports) {
-            if (id === './package.json')
-                continue;
-            const basename = id === '.' ? indexId : path.join(path.dirname(id), path.basename(id));
-            if (typeof pkg.exports[id] !== 'object') {
-                pkg.exports[id] = {};
-            }
-            if (isDeclarations) {
-                pkg.typesVersions['*'][id] = [`${config.dir}/${patternToName(typingsFilePattern, basename)}`];
-                pkg.exports[id].types = `./${config.dir}/${patternToName(typingsFilePattern, basename)}`;
-            }
-            const cjsFieldName = pkg.type === 'module' ? 'require' : 'default';
-            const esmFieldName = pkg.type === 'module' ? 'default' : 'import';
-            if (allowEsm) {
-                pkg.exports[id][esmFieldName] = `./${config.dir}/${patternToName(config.esPattern, basename)}`;
-            }
-            if (allowCjs) {
-                pkg.exports[id][cjsFieldName] = `./${config.dir}/${patternToName(config.commonjsPattern, basename)}`;
-            }
-            pkg.exports[id] = orderFields(exportsFields, pkg.exports[id]);
-            if (basename !== indexId && !config.noSubpackages) {
-                if (!pkg.files.includes(basename)) {
-                    pkg.files.push(basename);
-                }
-            }
-            await updateExtensions(basename);
-        }
-    }
-    else {
-        await updateExtensions(indexId);
-    }
-    if (isDeclarations) {
-        pkg.typesVersions['*']['*'] = [
-            `${config.dir}/${patternToName(typingsFilePattern, indexId)}`,
-            `${config.dir}/*`
-        ];
-        pkg.typesVersions['*'] = orderFields(emptySet, pkg.typesVersions['*'], typesVersionsLastFields);
-    }
-    if (allowUmd && config.umdInputs.length > 0 && !config.formats.includes('umd')) {
-        config.formats.push('umd');
-    }
-    for (const plugin of plugins) {
-        plugin.processPackageJson?.(pkg, inputs);
-    }
-    if (config.bin) {
-        if (config.bin.length > 0) {
-            if (config.bin[0] !== '') {
-                pkg.bin = config.bin[0];
-            }
-            config.bin = config.bin.filter(Boolean);
-            if (config.bin.length === 0) {
-                config.bin = undefined;
-            }
-        }
-    }
-    else if (allowCjs && inputs.length > 0) {
-        if (typeof pkg.bin === 'string') {
-            if (inputs.some(input => pkg.bin === `./${config.dir}/${patternToName(config.commonjsPattern, path.basename(input, path.extname(input)))}`)) {
-                config.bin = [pkg.bin];
-            }
-        }
-        else if (typeof pkg.bin === 'object' && pkg.bin !== null) {
-            const executables = Object.values(pkg.bin).filter(value => typeof value === 'string' && inputs.some(input => value === `./${config.dir}/${patternToName(config.commonjsPattern, path.basename(input, path.extname(input)))}`));
-            if (executables.length > 0) {
-                config.bin = executables;
-            }
-        }
-        if (typeof pkg.directories === 'object' && pkg.directories != null && 'bin' in pkg.directories && typeof pkg.directories.bin === 'string') {
-            if (path.resolve(pkg.directories.bin) === path.resolve(config.dir)) {
-                config.bin?.push(...inputs.map(input => `./${config.dir}/${patternToName(config.commonjsPattern, input)}`));
-                config.bin = Array.from(new Set(config.bin));
-            }
-        }
-    }
-    return [inputs, inputsExt];
-    async function updateExtensions(id) {
-        const sourceFileWithoutSuffix = `./${config.sourceDir}/${id}.`;
-        for (const suffix of sourceFileSuffixes) {
-            const file = sourceFileWithoutSuffix + suffix;
-            if (await isExists(file)) {
-                inputs.push(file);
-                inputsExt.set(id, suffix);
-                break;
-            }
-        }
-    }
-}
-function patternToName(pattern, input) {
-    return pattern.replace('[name]', input);
-}
-function orderFields(firstFields, exports, lastFields = emptySet) {
-    const ordered = {};
-    for (const key of firstFields) {
-        if (key in exports) {
-            ordered[key] = exports[key];
-        }
-    }
-    for (const key in exports) {
-        if (!firstFields.has(key) && !lastFields.has(key)) {
-            ordered[key] = exports[key];
-        }
-    }
-    for (const key of lastFields) {
-        if (key in exports) {
-            ordered[key] = exports[key];
-        }
-    }
-    return ordered;
-}
-
-async function writeJson(path, json) {
-    await fs.writeFile(path, toFormattedJson(json));
-}
-
-var dependencies = {
-	"@niceties/logger": "^1.1.13",
-	"@niceties/draftlog-appender": "^1.3.3",
-	lodash: "^4.17.21",
-	rollup: "^4.34.7",
-	"rollup-plugin-typescript2": "^0.36.0",
-	"rollup-plugin-preprocess": "^0.0.4",
-	"@rollup/plugin-commonjs": "^28.0.2",
-	"@rollup/plugin-terser": "^0.4.4",
-	"@rollup/plugin-json": "^6.1.0",
-	"@rollup/plugin-node-resolve": "^16.0.0",
-	"@rollup-extras/plugin-clean": "^1.3.9",
-	"@rollup-extras/plugin-binify": "^1.1.10",
-	"@rollup-extras/plugin-externals": "^1.2.2",
-	"@slimlib/refine-partition": "^1.0.3",
-	"@slimlib/smart-mock": "^0.1.6",
-	"is-builtin-module": "^3.2.1",
-	terser: "^5.39.0",
-	kleur: "^4.1.5",
-	cleye: "^1.3.4",
-	jsonata: "^2.0.6"
-};
-var pkgbldPkg = {
-	dependencies: dependencies};
-
-const imports = new Map;
-const setup = new Set;
-let generate, generateGlobals;
-async function createEjectProvider(preimportMap) {
-    const createMockProvider = (await import('@slimlib/smart-mock')).default;
-    const provider = createMockProvider();
-    const createMock = provider.createMock;
-    generate = provider.generate;
-    generateGlobals = provider.generateGlobals;
-    const plugins = [];
-    return [{
-            provide: (plugin, priority, options) => {
-                plugins.push({ priority, plugin, format: options?.format, inputs: options?.inputs, outputPlugin: options?.outputPlugin });
-            },
-            import: async (name, exportName) => {
-                const result = preimportMap.has(name) ? await preimportMap.get(name) : await import(name);
-                const exports = result[exportName ?? 'default'];
-                const mangledName = camelCase(name);
-                imports.set(name, mangledName);
-                return createMock(exports, mangledName);
-            },
-            globalImport: (module, exportName) => {
-                imports.set(module, exportName ?? 'default');
-            },
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-            globalSetup: (code) => {
-                if (typeof code === 'function') {
-                    setup.add(code.toString());
-                }
-                setup.add(String(code));
-            }
-        }, plugins];
-}
-async function ejectConfig(config, pkgPath, options, inputs, inputsExt, helpers, pkg) {
-    const pkgName = pkg.name;
-    // generate from config
-    const text = generate(config);
-    setup.add(generateGlobals());
-    // generate globals for config functions
-    setup.add(`const config = ${generate(options)}`);
-    setup.add(`const inputs = ${generate(inputs)}`);
-    setup.add(`const inputsExt = new Map(${generate(Array.from(inputsExt))})`);
-    // generate helpers code
-    if (options.formats.includes('umd')) {
-        imports.set('path', 'path');
-        imports.set('lodash/camelCase.js', 'camelCase');
-        imports.set('url', 'url'); // for __dirname polyfill
-        setup.add(`const pkgName = ${generate(pkgName)}`);
-        setup.add(helpers.getGlobalName.toString());
-        // polyfill __dirname
-        setup.add('const __dirname = url.fileURLToPath(new URL(\'.\', import.meta.url));');
-    }
-    // imports
-    const importsString = Array.from(imports)
-        .map((value) => `import ${value[1]} from '${value[0]}';`)
-        .join('\n');
-    const setupString = Array.from(setup)
-        .join('\n');
-    const { minify } = await import('terser');
-    const result = await minify(`${importsString}\n${setupString}\nexport default ${text};`, {
-        module: true,
-        compress: {
-            booleans: false,
-            ecma: 2020,
-            module: true,
-            passes: 3,
-            unsafe: true
-        },
-        mangle: false,
-        output: {
-            beautify: true,
-            ecma: 2020,
-            quote_style: 1
-        }
-    });
-    await fs.writeFile(path.join(path.dirname(pkgPath), 'rollup.config.mjs'), result.code);
-    await updatePackageJson(pkg);
-}
-async function updatePackageJson(pkg) {
-    if (typeof pkg.devDependencies !== 'object') {
-        pkg.devDependencies = {};
-    }
-    const devDependencies = pkg.devDependencies;
-    if ('pkgbld' in devDependencies) {
-        devDependencies.pkgbld = undefined;
-    }
-    devDependencies.rollup = pkgbldPkg.dependencies.rollup;
-    const isBuiltin = (await import('is-builtin-module')).default;
-    for (const key of imports.keys()) {
-        const packageName = getPackageName(key);
-        if (!isBuiltin(packageName)) {
-            devDependencies[packageName] = pkgbldPkg.dependencies[packageName] ?? '*';
-        }
-    }
-}
-function getPackageName(key) {
-    return key.split('/').slice(0, key.startsWith('@') ? 2 : 1).join('/');
-}
-
-const defaultTsConfig = {
-    include: ['src', 'types'],
-    compilerOptions: {
-        lib: ['dom', 'esnext'],
-        target: 'esnext',
-        module: 'esnext',
-        esModuleInterop: true,
-        allowJs: true,
-        skipLibCheck: true,
-        strict: true,
-        sourceMap: true,
-        noUncheckedIndexedAccess: true,
-        declaration: true,
-        moduleResolution: 'node'
-    }
-};
-async function checkTsConfig(options, mainLogger, plugins) {
-    if (options.noTsConfig) {
-        return;
-    }
-    // biome-ignore lint/style/useSingleVarDeclarator: <explanation>
-    let config, needWrite = false;
-    try {
-        [, config] = await getJson('tsconfig.json');
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (_) { /*ignore*/ }
-    try {
-        [, config] = await getJson('jsconfig.json');
-        if (config && typeof config === 'object' && !Array.isArray(config)) {
-            config.allowJs = true;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (_) { /*ignore*/ }
-    if (!config) {
-        config = defaultTsConfig;
-        needWrite = true;
-    }
-    const originalConfig = cloneDeep(config);
-    for (const plugin of plugins) {
-        plugin.processTsConfig?.(config);
-    }
-    if (!isEqual(originalConfig, config)) {
-        needWrite = true;
-    }
-    if (needWrite) {
-        mainLogger('no tsconfig.json or jsconfig.json and --no-ts-config not specified, writing tsconfig...');
-        await writeJson(path.resolve('tsconfig.json'), config);
-        mainLogger('done');
-    }
-    return config;
-}
-
-async function loadPlugins(pkg, loaded) {
-    try {
-        return await Promise.all([...new Set([...Object.keys(pkg.devDependencies || {}), ...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.peerDependencies || {})])]
-            .filter(packageName => packageName.startsWith('pkgbld-plugin-') && !loaded.has(packageName))
-            .map(packageName => {
-            loaded.add(packageName);
-            return import(packageName).then((pluginFactory) => pluginFactory.create());
-        }));
-    }
-    catch (e) {
-        console.error(e);
-        return [];
-    }
-}
-
-async function prunePkg(pkg, options, logger) {
-    const scriptsToKeep = getScriptsData();
-    const keys = scriptsToKeep[options.profile];
-    if (!keys) {
-        throw new Error(`unknown profile ${options.profile}`);
-    }
-    pkg.devDependencies = undefined;
-    pkg.packageManager = undefined;
-    if (pkg.scripts) {
-        for (const key of Object.keys(pkg.scripts)) {
-            if (!keys.has(key)) {
-                delete pkg.scripts[key];
-            }
-        }
-        if (Object.keys(pkg.scripts).length === 0) {
-            pkg.scripts = undefined;
-        }
-    }
-    if (options.flatten) {
-        await flatten(pkg, options.flatten, logger);
-    }
-    if (options.removeSourcemaps) {
-        const sourceMaps = await walkDir('.', ['node_modules']).then(files => files.filter(file => file.endsWith('.map')));
-        for (const sourceMap of sourceMaps) {
-            // find corresponding file
-            const sourceFile = sourceMap.slice(0, -4);
-            // load file
-            const sourceFileContent = await readFile(sourceFile, 'utf8');
-            // find sourceMappingURL
-            const sourceMappingUrl = `\n//# sourceMappingURL=${path.basename(sourceMap)}`;
-            // remove sourceMappingURL
-            const newContent = sourceFileContent.replace(sourceMappingUrl, '');
-            // write file
-            await writeFile(sourceFile, newContent, 'utf8');
-            // remove sourceMap
-            await rm(sourceMap);
-        }
-    }
-    if (pkg.files && Array.isArray(pkg.files) && options.optimizeFiles) {
-        const filterFiles = ['package.json'];
-        const specialFiles = ['README', 'LICENSE', 'LICENCE'];
-        if (pkg.main && typeof pkg.main === 'string') {
-            filterFiles.push(normalizePath(pkg.main));
-        }
-        if (pkg.bin) {
-            if (typeof pkg.bin === 'string') {
-                filterFiles.push(normalizePath(pkg.bin));
-            }
-            if (typeof pkg.bin === 'object' && pkg.bin !== null) {
-                filterFiles.push(...Object.values(pkg.bin).map(normalizePath));
-            }
-        }
-        const depthToFiles = new Map();
-        for (const file of pkg.files.concat(filterFiles)) {
-            const dirname = path.dirname(file);
-            const depth = dirname.split('/').length;
-            if (!depthToFiles.has(depth)) {
-                depthToFiles.set(depth, [file]);
-            }
-            else {
-                depthToFiles.get(depth)?.push(file);
-            }
-        }
-        // walk depth keys from the highest to the lowest
-        const maxDepth = Math.max(...depthToFiles.keys());
-        for (let depth = maxDepth; depth > 0; --depth) {
-            const files = depthToFiles.get(depth);
-            const mapDirToFiles = new Map();
-            for (const file of files) {
-                const dirname = path.dirname(file);
-                const basename = normalizePath(path.basename(file));
-                if (!mapDirToFiles.has(dirname)) {
-                    mapDirToFiles.set(dirname, [basename]);
-                }
-                else {
-                    mapDirToFiles.get(dirname)?.push(basename);
-                }
-            }
-            for (const [dirname, filesInDir] of mapDirToFiles) {
-                // find out real content of the directory
-                const realFiles = await readdir(dirname);
-                // check if all files in the directory are in the filesInDir
-                const allFilesInDir = realFiles.every(file => filesInDir.includes(file)) || realFiles.length === 0;
-                if (allFilesInDir && dirname !== '.') {
-                    if (!depthToFiles.has(depth - 1)) {
-                        depthToFiles.set(depth - 1, [dirname]);
-                    }
-                    else {
-                        depthToFiles.get(depth - 1).push(dirname);
-                    }
-                    const thisDepth = depthToFiles.get(depth);
-                    depthToFiles.set(depth, thisDepth.filter(file => filesInDir.every(fileInDir => path.join(dirname, fileInDir) !== file)));
-                }
-            }
-        }
-        pkg.files = [...new Set(Array.from(depthToFiles.values()).flat())];
-        pkg.files = pkg.files.filter(file => {
-            const fileNormalized = normalizePath(file);
-            const dirname = path.dirname(fileNormalized);
-            const basenameWithoutExtension = path.basename(fileNormalized, path.extname(fileNormalized)).toUpperCase();
-            return !filterFiles.includes(fileNormalized) && (dirname !== '' && dirname !== '.' || !specialFiles.includes(basenameWithoutExtension));
-        });
-        const ignoreDirs = [];
-        for (const fileOrDir of pkg.files) {
-            if (await isDirectory(fileOrDir)) {
-                const allFiles = await walkDir(fileOrDir);
-                if (allFiles.every(file => {
-                    const fileNormalized = normalizePath(file);
-                    return filterFiles.includes(fileNormalized);
-                })) {
-                    ignoreDirs.push(fileOrDir);
-                }
-            }
-        }
-        pkg.files = pkg.files.filter(dir => !ignoreDirs.includes(dir));
-        if (pkg.files.length === 0) {
-            pkg.files = undefined;
-        }
-    }
-}
-async function flatten(pkg, flatten, logger) {
-    const { default: jsonata } = await import('jsonata');
-    // find out where is the dist folder
-    const expression = jsonata('[bin, bin.*, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*, directories.bin]');
-    const allReferences = (await expression.evaluate(pkg));
-    let distDir;
-    // at this point we requested directories.bin, but it is the only one that is directory and not a file
-    // later when we get dirname we can't flatten directories.bin completely
-    // it is easy to fix by checking element is a directory but it is kind of good
-    // to have it as a separate directory, but user still can flatten it by specifying the directory
-    if (flatten === true) {
-        let commonSegments;
-        for (const entry of allReferences) {
-            if (typeof entry !== 'string') {
-                continue;
-            }
-            const dirname = path.dirname(entry);
-            const cleanedSegments = dirname.split('/').filter(path => path && path !== '.');
-            if (!commonSegments) {
-                commonSegments = cleanedSegments;
-            }
-            else {
-                for (let i = 0; i < commonSegments.length; ++i) {
-                    if (commonSegments[i] !== cleanedSegments[i]) {
-                        commonSegments.length = i;
-                        break;
-                    }
-                }
-            }
-        }
-        distDir = commonSegments?.join('/');
-    }
-    else {
-        distDir = normalizePath(flatten);
-    }
-    if (!distDir) {
-        throw new Error('could not find dist folder');
-    }
-    logger.update(`flattening ${distDir}...`);
-    // check if dist can be flattened
-    const relativeDistDir = `./${distDir}`;
-    const existsPromises = [];
-    const filesInDist = await walkDir(relativeDistDir);
-    for (const file of filesInDist) {
-        // check file is not in root dir
-        const relativePath = path.relative(relativeDistDir, file);
-        existsPromises.push(isExists(relativePath));
-    }
-    const exists = await Promise.all(existsPromises);
-    const filesAlreadyExist = exists.filter(Boolean);
-    if (filesAlreadyExist.length) {
-        throw new Error(`dist folder cannot be flattened because files already exist: ${filesAlreadyExist.join(', ')}`);
-    }
-    if (typeof flatten === 'string' && 'directories' in pkg && pkg.directories != null
-        && typeof pkg.directories === 'object' && 'bin' in pkg.directories
-        && typeof pkg.directories.bin === 'string' && normalizePath(pkg.directories.bin) === normalizePath(flatten)) {
-        // biome-ignore lint/performance/noDelete: <explanation>
-        delete pkg.directories.bin;
-        if (Object.keys(pkg.directories).length === 0) {
-            pkg.directories = undefined;
-        }
-        const files = await readdir(flatten);
-        if (files.length === 1) {
-            pkg.bin = files[0];
-        }
-        else {
-            pkg.bin = {};
-            for (const file of files) {
-                pkg.bin[path.basename(file, path.extname(file))] = file;
-            }
-        }
-    }
-    // create new directory structure
-    const mkdirPromises = [];
-    for (const file of filesInDist) {
-        // check file is not in root dir
-        const relativePath = path.relative(relativeDistDir, file);
-        mkdirPromises.push(mkdir(path.dirname(relativePath), { recursive: true }));
-    }
-    await Promise.all(mkdirPromises);
-    // move files to root dir (rename)
-    const renamePromises = [];
-    const newFiles = [];
-    for (const file of filesInDist) {
-        // check file is not in root dir
-        const relativePath = path.relative(relativeDistDir, file);
-        newFiles.push(relativePath);
-        renamePromises.push(rename(file, relativePath));
-    }
-    await Promise.all(renamePromises);
-    let cleanedDir = relativeDistDir;
-    while (await isEmptyDir(cleanedDir)) {
-        await rm(cleanedDir, { recursive: true, force: true });
-        const parentDir = path.dirname(cleanedDir);
-        if (parentDir === '.') {
-            break;
-        }
-        cleanedDir = parentDir;
-    }
-    const normalizedCleanDir = normalizePath(cleanedDir);
-    const allReferencesSet = new Set(allReferences);
-    // update package.json
-    const stringToReplace = `${distDir}/`; // we append / to remove in from the middle of the string
-    const pkgClone = cloneAndUpdate(pkg, value => allReferencesSet.has(value) ? value.replace(stringToReplace, '') : value);
-    Object.assign(pkg, pkgClone);
-    // update files
-    let files = pkg.files;
-    if (files) {
-        files = files.filter(file => {
-            const fileNormalized = normalizePath(file);
-            return !isSubDirectory(cleanedDir, fileNormalized) && fileNormalized !== normalizedCleanDir;
-        });
-        files.push(...newFiles);
-        pkg.files = [...files];
-    }
-    // remove extra directories with package.json
-    const exports = pkg.exports ? Object.keys(pkg.exports) : [];
-    for (const key of exports) {
-        if (key === '.') {
-            continue;
-        }
-        const isDir = await isDirectory(key);
-        if (isDir) {
-            const pkgPath = path.join(key, 'package.json');
-            const pkgExists = await isExists(pkgPath);
-            // ensure nothing else is in the directory
-            const files = await readdir(key);
-            if (files.length === 1 && pkgExists) {
-                await rm(key, { recursive: true, force: true });
-            }
-        }
-    }
-}
-function normalizePath(file) {
-    let fileNormalized = path.normalize(file);
-    if (fileNormalized.endsWith('/') || fileNormalized.endsWith('\\')) {
-        // remove trailing slash
-        fileNormalized = fileNormalized.slice(0, -1);
-    }
-    return fileNormalized;
-}
-function cloneAndUpdate(pkg, updater) {
-    if (typeof pkg === 'string') {
-        return updater(pkg);
-    }
-    if (Array.isArray(pkg)) {
-        return pkg.map(value => cloneAndUpdate(value, updater));
-    }
-    if (typeof pkg === 'object' && pkg !== null) {
-        const clone = {};
-        for (const key of Object.keys(pkg)) {
-            clone[key] = cloneAndUpdate(pkg[key], updater);
-        }
-        return clone;
-    }
-    return pkg;
-}
-function isSubDirectory(parent, child) {
-    return path.relative(child, parent).startsWith('..');
-}
-async function isEmptyDir(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    return entries.filter(entry => !entry.isDirectory()).length === 0;
-}
-async function isDirectory(file) {
-    const fileStat = await stat(file);
-    return fileStat.isDirectory();
-}
-async function walkDir(dir, ignoreDirs = []) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    const files = [];
-    await Promise.all(entries.map(entry => {
-        const childPath = path.join(dir, entry.name);
-        if (entry.isDirectory() && !ignoreDirs.includes(entry.name)) {
-            return walkDir(childPath)
-                .then(childFiles => {
-                files.push(...childFiles);
-            });
-        }
-        files.push(childPath);
-    }).filter(Boolean));
-    return files;
-}
-function getScriptsData() {
-    const libraryScripts = new Set([
-        'preinstall',
-        'install',
-        'postinstall',
-        'prepublish',
-        'preprepare',
-        'prepare',
-        'postprepare'
-    ]);
-    const appScripts = new Set([
-        ...libraryScripts,
-        'prestart',
-        'start',
-        'poststart',
-        'prerestart',
-        'restart',
-        'postrestart',
-        'prestop',
-        'stop',
-        'poststop',
-        'pretest',
-        'test',
-        'posttest'
-    ]);
-    return {
-        library: libraryScripts,
-        app: appScripts
-    };
-}
-
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="./rollup-plugin-preprocess.d.ts" />
-execute();
-async function execute() {
-    const time = Date.now();
-    const mainLogger = createLogger();
-    mainLogger.update('preparing..');
-    try {
-        let pkg;
-        let pkgPath;
-        // eslint-disable-next-line prefer-const
-        [pkgPath, pkg] = await getJson('package.json');
-        const loadedPlugins = new Set;
-        const plugins = await loadPlugins(pkg, loadedPlugins);
-        const [rootPackagePath, rootPkg] = await getJson(join(await searchForWorkspaceRoot(dirname(pkgPath)), 'package.json'));
-        if (rootPackagePath !== pkgPath) {
-            plugins.push(...await loadPlugins(rootPkg, loadedPlugins));
-        }
-        mainLogger.update('');
-        process.stdout.moveCursor?.(0, -1);
-        const options = getCliOptions(plugins, pkg);
-        if (options.kind === 'prune') {
-            await prunePkg(pkg, options, mainLogger);
-            await writeJson(pkgPath, pkg);
-            process.exit(0);
-        }
-        process.stdout.moveCursor?.(0, 1);
-        mainLogger.update('preparing...');
-        const tsConfig = await checkTsConfig(options, mainLogger, plugins);
-        const [inputs, inputsExt] = await processPackage(pkg, options, plugins, tsConfig);
-        if (options.formatPackageJson) {
-            pkg = formatPackageJson(pkg);
-        }
-        const helpers = getHelpers(pkg.name);
-        const preimportMap = preimport();
-        const provider = options.eject ? await createEjectProvider(preimportMap) : createProvider(preimportMap);
-        const rollupConfigs = await getRollupConfigs(provider, inputs, inputsExt, options, helpers, plugins);
-        if (options.noBundle) {
-            rollupConfigs.length = 0;
-        }
-        if (options.eject) {
-            await ejectConfig(rollupConfigs, pkgPath, options, inputs, inputsExt, helpers, pkg);
-            mainLogger.finish(`ejected config in ${getTimeDiff(time)}`);
-            if (!options.noUpdatePackageJson) {
-                await writeJson(pkgPath, pkg);
-            }
-        }
-        else {
-            const updater = mainLoggerText(options.sourceDir, options.dir, rollupConfigs.length, time);
-            mainLogger.start(updater());
-            await Promise.all(rollupConfigs.map(config => buildConfig(config, updater)));
-            if (!options.noUpdatePackageJson) {
-                await writeJson(pkgPath, pkg);
-            }
-            if (!options.noSubpackages) {
-                await createSubpackages(inputs, options);
-            }
-            await Promise.all(plugins
-                .filter(plugin => plugin.buildEnd)
-                .map(plugin => plugin.buildEnd()));
-            mainLogger.finish(updater(true));
-        }
-    }
-    catch (e) {
-        mainLogger.finish(String(e), 3 /* LogLevel.error */);
-        process.exit(-1);
-    }
-    async function buildConfig(config, updater) {
-        const bundle = await rollup(config);
-        await Promise.all(toArray(config.output).map(config => bundle.write(config)));
-        await bundle.close();
-        mainLogger(`${kleur.green('✓')} ${formatInput(config.input)} [${formatOutput(config.output, 'format')}]`);
-        mainLogger.update(updater());
-    }
-}
-function preimport() {
-    return (process.env.PKGBLD_INTERNAL ? new Map([
-        ['@rollup-extras/plugin-binify', import('@rollup-extras/plugin-binify')],
-        ['@rollup-extras/plugin-clean', import('@rollup-extras/plugin-clean')],
-        ['@rollup-extras/plugin-externals', import('@rollup-extras/plugin-externals')]
-    ]) : new Map);
-}
-process.on('exit', () => { });