pkgprn-internal 0.5.2

package/dist/index.mjs

@@ -0,0 +1,1413 @@
+import { readFile, writeFile, rm, readdir, mkdir, rename, stat, access } from 'node:fs/promises';
+import path, { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cli } from 'cleye';
+import { decode, encode } from '@jridgewell/sourcemap-codec';
+
+let globalAppender;
+const appender = (appender) => {
+    if (appender !== undefined) {
+        globalAppender = appender;
+    }
+    return globalAppender;
+};
+
+let globalInputId = 0;
+const getOptions = (options) => {
+    let parentId, tag;
+    if (options.length === 1) {
+        if (typeof options[0] === 'string') {
+            tag = options[0];
+        }
+        else {
+            parentId = options[0]?.id;
+        }
+    }
+    else if (options.length === 2) {
+        tag = options[0];
+        parentId = options[1]?.id;
+    }
+    return { parentId, tag };
+};
+const createLogger = (...args) => {
+    let initialLogLevel = 1 ;
+    let myAppender = (message) => { globalAppender && globalAppender(message); };
+    const inputId = globalInputId++;
+    const { tag, parentId } = getOptions(args);
+    const append = (message, action, loglevel, context) => {
+        myAppender && myAppender({
+            action,
+            inputId,
+            message,
+            loglevel,
+            tag,
+            parentId,
+            ref,
+            context
+        });
+    };
+    const loggerInstance = Object.assign((message, loglevel = 1 , context) => {
+        append(message, 3 , loglevel, context);
+    }, {
+
+        start(message, loglevel, context) {
+            if (loglevel !== undefined) {
+                initialLogLevel = loglevel;
+            }
+            append(message, 0 , initialLogLevel, context);
+        },
+
+        update(message, loglevel, context) {
+            append(message, 1 , loglevel ?? initialLogLevel, context);
+        },
+
+        finish(message, loglevel, context) {
+            append(message, 2 , loglevel ?? initialLogLevel, context);
+        },
+        appender(appender) {
+            if (appender !== undefined) {
+                myAppender = appender;
+            }
+            return myAppender;
+        }
+    });
+    Object.defineProperty(loggerInstance, 'id', {
+        value: inputId,
+        writable: false
+    });
+    const ref = new WeakRef(loggerInstance);
+    return loggerInstance;
+};
+
+if (!appender()) {
+    const [{ asciiPrefixes, colors, unicodePrefixes, tagFactory }, { createConsoleAppender }, { createFormatter, terminalSupportsUnicode }, { filterMessages }] = await Promise.all([
+        import('./default-formatting.Dpf5rT0f.mjs'),
+        import('./console-appender.D0FERGUF.mjs'),
+        import('./format-utils.CGsPFFMS.mjs'),
+        import('./appender-utils.B51llXhb.mjs')
+    ]);
+    const formatter = createFormatter(colors, terminalSupportsUnicode() ? unicodePrefixes : asciiPrefixes, tagFactory);
+    let minLogLevel = 1 ;
+    appender(filterMessages((message) => message.loglevel >= minLogLevel, createConsoleAppender(formatter),
+    { setMinLevel(logLevel) { minLogLevel = logLevel; } }
+    ));
+}
+
+function extractReferences(pkg) {
+
+    const result = [];
+
+    if (pkg.bin !== undefined && pkg.bin !== null) {
+        result.push(pkg.bin);
+    }
+
+    if (typeof pkg.bin === 'object' && pkg.bin !== null && !Array.isArray(pkg.bin)) {
+        for (const value of Object.values(pkg.bin)) {
+            result.push(value);
+        }
+    }
+
+    const topLevelFields = ['main', 'module', 'unpkg', 'umd', 'types', 'typings'];
+    for (const field of topLevelFields) {
+        if (pkg[field] !== undefined && pkg[field] !== null) {
+            result.push(pkg[field]);
+        }
+    }
+
+    if (typeof pkg.exports === 'object' && pkg.exports !== null && !Array.isArray(pkg.exports)) {
+        for (const level1 of Object.values(pkg.exports)) {
+            if (typeof level1 === 'object' && level1 !== null && !Array.isArray(level1)) {
+                for (const level2 of Object.values( (level1))) {
+                    if (Array.isArray(level2)) {
+                        for (const item of level2) {
+                            result.push(item);
+                        }
+                    } else {
+                        result.push(level2);
+                    }
+                }
+            }
+        }
+    }
+
+    if (typeof pkg.typesVersions === 'object' && pkg.typesVersions !== null && !Array.isArray(pkg.typesVersions)) {
+        for (const level1 of Object.values(pkg.typesVersions)) {
+            if (typeof level1 === 'object' && level1 !== null && !Array.isArray(level1)) {
+                for (const level2 of Object.values( (level1))) {
+                    if (Array.isArray(level2)) {
+                        for (const item of level2) {
+                            result.push(item);
+                        }
+                    } else {
+                        result.push(level2);
+                    }
+                }
+            }
+        }
+    }
+
+    if (typeof pkg.directories === 'object' && pkg.directories !== null) {
+        const dirs =  (pkg.directories);
+        if (dirs.bin !== undefined && dirs.bin !== null) {
+            result.push(dirs.bin);
+        }
+    }
+
+    return result;
+}
+
+const jsExtensions = ['.js', '.mjs', '.cjs'];
+
+function isStrippableFile(file) {
+    return jsExtensions.some(ext => file.endsWith(ext));
+}
+
+const regexPrecedingKeywords = new Set([
+    'return',
+    'throw',
+    'typeof',
+    'void',
+    'delete',
+    'new',
+    'in',
+    'instanceof',
+    'case',
+    'yield',
+    'await',
+    'of',
+    'export',
+    'import',
+    'default',
+    'extends',
+    'else',
+]);
+
+function classifyBlockComment(source, start, end) {
+
+    if (source[start + 2] === '!') {
+        return 'license';
+    }
+
+    const body = source.slice(start + 2, end - 2);
+    if (body.includes('@license') || body.includes('@preserve')) {
+        return 'license';
+    }
+
+    if (source[start + 2] === '*' && end - start > 4) {
+        return 'jsdoc';
+    }
+
+    return 'regular';
+}
+
+function scanComments(source) {
+
+    const comments = [];
+    const len = source.length;
+    let i = 0;
+
+    const templateStack = [];
+
+    let exprEnd = false;
+
+    if (len >= 2 && source[0] === '#' && source[1] === '!') {
+
+        while (i < len && source[i] !== '\n') i++;
+
+    }
+
+    while (i < len) {
+        const ch = source.charCodeAt(i);
+
+        if (ch <= 0x20 || ch === 0xfeff || ch === 0xa0) {
+            i++;
+            continue;
+        }
+
+        if (ch === 0x2f  && i + 1 < len && source.charCodeAt(i + 1) === 0x2f ) {
+            const start = i;
+            i += 2;
+            while (i < len && source.charCodeAt(i) !== 0x0a ) i++;
+            comments.push({ start, end: i, type: 'regular' });
+
+            continue;
+        }
+
+        if (ch === 0x2f  && i + 1 < len && source.charCodeAt(i + 1) === 0x2a ) {
+            const start = i;
+            i += 2;
+            while (i < len && !((source.charCodeAt(i) === 0x2a  && i + 1 < len && source.charCodeAt(i + 1) === 0x2f) )) {
+                i++;
+            }
+            if (i < len) i += 2;
+            comments.push({ start, end: i, type: classifyBlockComment(source, start, i) });
+
+            continue;
+        }
+
+        if (ch === 0x2f  && !exprEnd) {
+            i = skipRegex(source, i, len);
+            exprEnd = true;
+            continue;
+        }
+
+        if (ch === 0x27 ) {
+            i = skipSingleString(source, i, len);
+            exprEnd = true;
+            continue;
+        }
+
+        if (ch === 0x22 ) {
+            i = skipDoubleString(source, i, len);
+            exprEnd = true;
+            continue;
+        }
+
+        if (ch === 0x60 ) {
+            i = scanTemplateTail(source, i + 1, len, templateStack);
+            exprEnd = true;
+            continue;
+        }
+
+        if (ch === 0x7d ) {
+            if (templateStack.length > 0) {
+                const depth = templateStack[templateStack.length - 1];
+                if (depth === 0) {
+
+                    templateStack.pop();
+                    i = scanTemplateTail(source, i + 1, len, templateStack);
+                    exprEnd = true;
+                    continue;
+                }
+                templateStack[templateStack.length - 1] = depth - 1;
+            }
+            i++;
+
+            exprEnd = false;
+            continue;
+        }
+
+        if (ch === 0x7b ) {
+            if (templateStack.length > 0) {
+                templateStack[templateStack.length - 1]++;
+            }
+            i++;
+            exprEnd = false;
+            continue;
+        }
+
+        if (isIdentStart(ch) || isDigit(ch)) {
+            const wordStart = i;
+            i++;
+            while (i < len && isIdentPart(source.charCodeAt(i))) i++;
+            const word = source.slice(wordStart, i);
+            exprEnd = !regexPrecedingKeywords.has(word);
+            continue;
+        }
+
+        if ((ch === 0x2b  || ch === 0x2d)  && i + 1 < len && source.charCodeAt(i + 1) === ch) {
+            i += 2;
+            exprEnd = true;
+            continue;
+        }
+
+        if (ch === 0x29  || ch === 0x5d ) {
+            i++;
+            exprEnd = true;
+            continue;
+        }
+
+        i++;
+        exprEnd = false;
+    }
+
+    return comments;
+}
+
+function isDigit(ch) {
+    return ch >= 0x30 && ch <= 0x39;
+}
+
+function isIdentStart(ch) {
+    return (
+        (ch >= 0x41 && ch <= 0x5a) ||
+        (ch >= 0x61 && ch <= 0x7a) ||
+        ch === 0x5f ||
+        ch === 0x24 ||
+        ch === 0x5c ||
+        ch > 0x7f
+    );
+}
+
+function isIdentPart(ch) {
+    return isIdentStart(ch) || isDigit(ch);
+}
+
+function skipSingleString(s, i, len) {
+    i++;
+    while (i < len) {
+        const ch = s.charCodeAt(i);
+        if (ch === 0x27 ) {
+            i++;
+            break;
+        }
+        if (ch === 0x5c ) {
+            i += 2;
+            continue;
+        }
+        if (ch === 0x0a  || ch === 0x0d ) break;
+        i++;
+    }
+    return i;
+}
+
+function skipDoubleString(s, i, len) {
+    i++;
+    while (i < len) {
+        const ch = s.charCodeAt(i);
+        if (ch === 0x22 ) {
+            i++;
+            break;
+        }
+        if (ch === 0x5c ) {
+            i += 2;
+            continue;
+        }
+        if (ch === 0x0a || ch === 0x0d) break;
+        i++;
+    }
+    return i;
+}
+
+function skipRegex(s, i, len) {
+    i++;
+    while (i < len) {
+        const ch = s.charCodeAt(i);
+        if (ch === 0x5c ) {
+            i += 2;
+            continue;
+        }
+        if (ch === 0x5b ) {
+
+            i++;
+            while (i < len) {
+                const cc = s.charCodeAt(i);
+                if (cc === 0x5c ) {
+                    i += 2;
+                    continue;
+                }
+                if (cc === 0x5d ) {
+                    i++;
+                    break;
+                }
+                if (cc === 0x0a || cc === 0x0d) break;
+                i++;
+            }
+            continue;
+        }
+        if (ch === 0x2f ) {
+            i++;
+
+            while (i < len && isRegexFlag(s.charCodeAt(i))) i++;
+            break;
+        }
+        if (ch === 0x0a || ch === 0x0d) break;
+        i++;
+    }
+    return i;
+}
+
+function isRegexFlag(ch) {
+    return ch >= 0x61 && ch <= 0x7a;
+}
+
+function scanTemplateTail(s, i, len, templateStack, comments) {
+    while (i < len) {
+        const ch = s.charCodeAt(i);
+        if (ch === 0x5c ) {
+            i += 2;
+            continue;
+        }
+        if (ch === 0x60 ) {
+            i++;
+            return i;
+        }
+        if (ch === 0x24  && i + 1 < len && s.charCodeAt(i + 1) === 0x7b ) {
+            i += 2;
+            templateStack.push(0);
+            return i;
+        }
+        i++;
+    }
+    return i;
+}
+
+function parseCommentTypes(value) {
+    if (value === true || value === 'all') {
+        return new Set( (['jsdoc', 'license', 'regular']));
+    }
+
+    const valid =  (['jsdoc', 'license', 'regular']);
+    const parts = String(value)
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean);
+
+    const result = new Set();
+
+    for (const part of parts) {
+        if (part === 'all') {
+            return new Set(valid);
+        }
+        if (!valid.includes( (part))) {
+            throw new Error(`unknown comment type "${part}" (expected: ${valid.join(', ')}, all)`);
+        }
+        result.add( (part));
+    }
+
+    if (result.size === 0) {
+        return new Set(valid);
+    }
+
+    return result;
+}
+
+function stripCommentsWithLineMap(source, typesToStrip) {
+    const comments = scanComments(source);
+
+    if (comments.length === 0) return { result: source, lineMap: null };
+
+    const toRemove = comments.filter(c => typesToStrip.has(c.type));
+
+    if (toRemove.length === 0) return { result: source, lineMap: null };
+
+    const parts = [];
+    let pos = 0;
+
+    for (const { start, end } of toRemove) {
+        if (start > pos) {
+            parts.push(source.slice(pos, start));
+        }
+        pos = end;
+    }
+
+    if (pos < source.length) {
+        parts.push(source.slice(pos));
+    }
+
+    let intermediate = parts.join('');
+
+    const origLines = source.split('\n');
+    const origLineCount = origLines.length;
+
+    function translateOffset(offset) {
+        let removed = 0;
+        for (const { start, end } of toRemove) {
+            if (offset < start) break;
+            if (offset < end) return -1;
+            removed += end - start;
+        }
+        return offset - removed;
+    }
+
+    const intermediateText = intermediate;
+    const intermediateLineStarts = buildLineStarts(intermediateText);
+
+    const origToIntermediate = new Int32Array(origLineCount).fill(-1);
+    let origOffset = 0;
+    for (let oi = 0; oi < origLineCount; oi++) {
+        const lineLen = origLines[oi].length;
+
+        let survived = false;
+        for (let ci = 0; ci < lineLen; ci++) {
+            const ch = source.charCodeAt(origOffset + ci);
+
+            if (ch === 0x20 || ch === 0x09 || ch === 0x0d) continue;
+            const mapped = translateOffset(origOffset + ci);
+            if (mapped !== -1) {
+                survived = true;
+
+                origToIntermediate[oi] = offsetToLine(intermediateLineStarts, mapped);
+                break;
+            }
+        }
+        if (!survived) {
+            origToIntermediate[oi] = -1;
+        }
+        origOffset += lineLen + 1;
+    }
+
+    intermediate = intermediate.replace(/[ \t]+$/gm, '');
+
+    intermediate = intermediate.replace(/\n{3,}/g, '\n\n');
+
+    if (intermediate.startsWith('#!')) {
+        const hashbangEnd = intermediate.indexOf('\n');
+        if (hashbangEnd !== -1) {
+            const before = intermediate.slice(0, hashbangEnd + 1);
+            const after = intermediate.slice(hashbangEnd + 1).replace(/^\n+/, '');
+            intermediate = before + after;
+        }
+    } else {
+        intermediate = intermediate.replace(/^\n+/, '');
+    }
+
+    if (source.endsWith('\n') && intermediate.length > 0) {
+        intermediate = intermediate.replace(/\n*$/, '\n');
+    }
+
+    const result = intermediate;
+
+    const finalLines = result.split('\n');
+    const intLines = intermediateText.split('\n');
+
+    const intLinesTrimmed = intLines.map(l => l.replace(/[ \t]+$/, ''));
+
+    const intermediateToFinal = new Int32Array(intLines.length).fill(-1);
+    let fi = 0;
+    for (let ii = 0; ii < intLinesTrimmed.length && fi < finalLines.length; ii++) {
+        if (intLinesTrimmed[ii] === finalLines[fi]) {
+            intermediateToFinal[ii] = fi;
+            fi++;
+        }
+
+    }
+
+    const lineMap = new Int32Array(origLineCount).fill(-1);
+    for (let oi = 0; oi < origLineCount; oi++) {
+        const il = origToIntermediate[oi];
+        if (il >= 0 && il < intermediateToFinal.length) {
+            lineMap[oi] = intermediateToFinal[il];
+        }
+    }
+
+    return { result, lineMap };
+}
+
+function buildLineStarts(text) {
+
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 0x0a) {
+            starts.push(i + 1);
+        }
+    }
+    return starts;
+}
+
+function offsetToLine(lineStarts, offset) {
+
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (lineStarts[mid] <= offset) {
+            lo = mid;
+        } else {
+            hi = mid - 1;
+        }
+    }
+    return lo;
+}
+
+function adjustSourcemapLineMappings(map, sourceIndex, lineMap) {
+    if (map.version !== 3 || typeof map.mappings !== 'string') return;
+
+    const decoded = decode(map.mappings);
+
+    for (const line of decoded) {
+
+        for (let si = line.length - 1; si >= 0; si--) {
+            const seg = line[si];
+
+            if (seg.length < 4) continue;
+            const seg4 =  (seg);
+
+            if (seg4[1] !== sourceIndex) continue;
+
+            const origLine = seg4[2];
+            if (origLine < 0 || origLine >= lineMap.length) {
+
+                line.splice(si, 1);
+                continue;
+            }
+
+            const newLine = lineMap[origLine];
+            if (newLine === -1) {
+
+                line.splice(si, 1);
+                continue;
+            }
+
+            seg4[2] = newLine;
+        }
+    }
+
+    map.mappings = encode(decoded);
+}
+
+const alwaysIncludedExact = ['package.json'];
+const alwaysIncludedBasenames = ['README', 'LICENSE', 'LICENCE'];
+
+const alwaysIgnored = ['.DS_Store', '.hg', '.lock-wscript', '.svn', 'CVS', 'config.gypi', 'npm-debug.log'];
+
+const alwaysIgnoredPatterns = [
+
+    { test: ( basename) => basename.endsWith('.orig') },
+
+    { test: ( basename) => basename.startsWith('.') && basename.endsWith('.swp') },
+
+    { test: ( basename) => basename.startsWith('._') },
+
+    { test: ( basename) => /^\.wafpickle-\d+$/.test(basename) },
+];
+
+const hardIgnored = new Set(['.git', '.npmrc', 'node_modules', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb']);
+
+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.cleanupFiles) {
+        await removeJunkFiles('.');
+    } else if (options.flatten) {
+        logger('cleanup is disabled, junk files may cause flatten to fail', 2);
+    }
+
+    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) {
+
+            const sourceFile = sourceMap.slice(0, -4);
+
+            const sourceFileContent = await readFile(sourceFile, 'utf8');
+
+            const sourceMappingUrl = `\n//# sourceMappingURL=${path.basename(sourceMap)}`;
+
+            const newContent = sourceFileContent.replace(sourceMappingUrl, '');
+
+            await writeFile(sourceFile, newContent, 'utf8');
+
+            await rm(sourceMap);
+        }
+    }
+
+    if (options.stripComments) {
+        const typesToStrip = parseCommentTypes( (options.stripComments));
+        logger.update('stripping comments...');
+        const allFiles = await walkDir('.', ['node_modules']);
+        const jsFiles = allFiles.filter(isStrippableFile);
+        const dtsMapFiles = allFiles.filter(f => f.endsWith('.d.ts.map'));
+
+        const lineMaps = new Map();
+        for (const file of jsFiles) {
+            const content = await readFile(file, 'utf8');
+            const { result: stripped, lineMap } = stripCommentsWithLineMap(content, typesToStrip);
+            if (lineMap) {
+                await writeFile(file, stripped, 'utf8');
+                lineMaps.set(path.normalize(file), lineMap);
+            }
+        }
+
+        if (lineMaps.size > 0 && dtsMapFiles.length > 0) {
+            for (const mapFile of dtsMapFiles) {
+                const mapContent = await readFile(mapFile, 'utf8');
+                let map;
+                try {
+                    map = JSON.parse(mapContent);
+                } catch {
+                    continue;
+                }
+                if (map.version !== 3 || !Array.isArray(map.sources)) continue;
+
+                const mapDir = path.dirname(mapFile) || '.';
+                let adjusted = false;
+                for (let si = 0; si < map.sources.length; si++) {
+                    const resolved = path.normalize(path.join(mapDir, map.sourceRoot || '', map.sources[si]));
+                    const lineMap = lineMaps.get(resolved);
+                    if (lineMap) {
+                        adjustSourcemapLineMappings(map, si, lineMap);
+                        adjusted = true;
+                    }
+                }
+                if (adjusted) {
+                    await writeFile(mapFile, `${JSON.stringify(map, null, '\t')}\n`, 'utf8');
+                }
+            }
+        }
+    }
+
+    if (pkg.files && Array.isArray(pkg.files) && options.optimizeFiles) {
+        const filterFiles = getAlwaysIncludedFiles(pkg);
+
+        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);
+            }
+        }
+
+        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) {
+
+                const realFiles = await readdir(dirname);
+
+                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 !== '.') || !alwaysIncludedBasenames.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;
+        }
+    }
+
+    if (pkg.files && Array.isArray(pkg.files) && options.cleanupFiles) {
+        await cleanupDir(pkg, logger);
+    }
+}
+
+async function flatten(pkg, flatten, logger) {
+
+    const allReferences = extractReferences(pkg);
+
+    let distDirs;
+
+    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;
+                    }
+                }
+            }
+        }
+        const distDir = commonSegments?.join('/');
+        if (!distDir) {
+            throw new Error('could not find dist folder');
+        }
+        distDirs = [distDir];
+    } else {
+
+        distDirs = flatten
+            .split(',')
+            .map(d => normalizePath(d.trim()))
+            .filter(Boolean);
+    }
+
+    logger.update(`flattening ${distDirs.join(', ')}...`);
+
+    const distDirInfo = new Map();
+
+    for (const distDir of distDirs) {
+        const relativeDistDir = `./${distDir}`;
+        const files = await walkDir(relativeDistDir);
+        distDirInfo.set(distDir, { distDir, relativeDistDir, files });
+    }
+
+    const destinationToSource = new Map();
+    const existsPromises = [];
+
+    for (const [distDir, info] of distDirInfo) {
+        for (const file of info.files) {
+            const relativePath = path.relative(info.relativeDistDir, file);
+
+            if (destinationToSource.has(relativePath)) {
+                const otherDir = destinationToSource.get(relativePath);
+                throw new Error(`cannot flatten because '${relativePath}' exists in both '${otherDir}' and '${distDir}'`);
+            }
+            destinationToSource.set(relativePath, distDir);
+            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(', ')}`);
+    }
+
+    for (const distDir of distDirs) {
+        if (
+            'directories' in pkg &&
+            pkg.directories != null &&
+            typeof pkg.directories === 'object' &&
+            'bin' in pkg.directories &&
+            typeof pkg.directories.bin === 'string' &&
+            normalizePath(pkg.directories.bin) === distDir
+        ) {
+            delete pkg.directories.bin;
+            if (Object.keys(pkg.directories).length === 0) {
+                pkg.directories = undefined;
+            }
+            const files = await readdir(distDir);
+            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;
+                }
+            }
+        }
+    }
+
+    const mkdirPromises = [];
+    for (const [, info] of distDirInfo) {
+        for (const file of info.files) {
+            const relativePath = path.relative(info.relativeDistDir, file);
+            mkdirPromises.push(mkdir(path.dirname(relativePath), { recursive: true }));
+        }
+    }
+
+    await Promise.all(mkdirPromises);
+
+    const renamePromises = [];
+    const newFiles = [];
+
+    const movedFiles = new Map();
+
+    for (const [, info] of distDirInfo) {
+        for (const file of info.files) {
+            const relativePath = path.relative(info.relativeDistDir, file);
+            newFiles.push(relativePath);
+            movedFiles.set(relativePath, file);
+            renamePromises.push(rename(file, relativePath));
+        }
+    }
+
+    await Promise.all(renamePromises);
+
+    if (typeof flatten === 'string') {
+
+        const oldToNew = new Map();
+        for (const [newPath, oldPath] of movedFiles) {
+            oldToNew.set(path.normalize(oldPath), newPath);
+        }
+
+        const sourcemapFiles = newFiles.filter(f => f.endsWith('.map'));
+        for (const newMapPath of sourcemapFiles) {
+            const oldMapPath = movedFiles.get(newMapPath);
+            if (oldMapPath) {
+                await adjustSourcemapPaths(newMapPath, oldMapPath, oldToNew);
+            }
+        }
+    }
+
+    const cleanedDirs = [];
+    for (const [, info] of distDirInfo) {
+        let cleanedDir = info.relativeDistDir;
+        while (await isEmptyDir(cleanedDir)) {
+            await rm(cleanedDir, { recursive: true, force: true });
+            const parentDir = path.dirname(cleanedDir);
+            if (parentDir === '.') {
+                break;
+            }
+            cleanedDir = parentDir;
+        }
+        cleanedDirs.push(normalizePath(cleanedDir));
+    }
+
+    const allReferencesSet = new Set(allReferences);
+
+    const stringsToReplace = distDirs.map(d => `${d}/`);
+    const pkgClone = cloneAndUpdate(pkg, value => {
+        if (!allReferencesSet.has(value)) {
+            return value;
+        }
+        for (const stringToReplace of stringsToReplace) {
+            if (value.includes(stringToReplace)) {
+                return value.replace(stringToReplace, '');
+            }
+        }
+        return value;
+    });
+    Object.assign(pkg, pkgClone);
+
+    let files = pkg.files;
+    if (files) {
+        files = files.filter(file => {
+            const fileNormalized = normalizePath(file);
+            return !cleanedDirs.some(cleanedDir => isSubDirectory(cleanedDir, fileNormalized) || fileNormalized === cleanedDir);
+        });
+        files.push(...newFiles);
+        pkg.files = [...files];
+    }
+
+    const exports$1 = pkg.exports ? Object.keys(pkg.exports) : [];
+    for (const key of exports$1) {
+        if (key === '.') {
+            continue;
+        }
+        const isDir = await isDirectory(key);
+        if (isDir) {
+            const pkgPath = path.join(key, 'package.json');
+            const pkgExists = await isExists(pkgPath);
+
+            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('\\')) {
+
+        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;
+}
+
+async function adjustSourcemapPaths(newMapPath, oldMapPath, oldToNew) {
+    const content = await readFile(newMapPath, 'utf8');
+
+    let map;
+    try {
+        map = JSON.parse(content);
+    } catch {
+        return;
+    }
+
+    if (map.version !== 3 || !Array.isArray(map.sources)) {
+        return;
+    }
+
+    const oldDir = path.dirname(oldMapPath) || '.';
+    const newDir = path.dirname(newMapPath) || '.';
+    const sourceRoot = map.sourceRoot || '';
+
+    map.sources = map.sources.map(( source) => {
+
+        const resolved = path.normalize(path.join(oldDir, sourceRoot, source));
+
+        const effective = oldToNew.get(resolved) ?? resolved;
+
+        const newRelative = path.relative(newDir, effective);
+
+        return newRelative.split(path.sep).join('/');
+    });
+
+    if (map.sourceRoot !== undefined) {
+        delete map.sourceRoot;
+    }
+
+    await writeFile(newMapPath, `${JSON.stringify(map, null, 2)}\n`, 'utf8');
+}
+
+function isSubDirectory(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel !== '' && !rel.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 = [];
+
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            const childPath = path.join(entry.parentPath, entry.name);
+            files.push(childPath);
+        }
+    }
+
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const childPath = path.join(entry.parentPath, entry.name);
+            const relativePath = path.relative(dir, childPath);
+            const topLevelDir = relativePath.split(path.sep)[0];
+
+            if (!ignoreDirs.includes(topLevelDir)) {
+                const childFiles = await walkDir(childPath);
+                files.push(...childFiles);
+            }
+        }
+    }
+
+    return files;
+}
+
+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;
+}
+
+function getAlwaysIncludedFiles(pkg) {
+    const files = [...alwaysIncludedExact];
+    if (pkg.main && typeof pkg.main === 'string') {
+        files.push(normalizePath(pkg.main));
+    }
+    if (pkg.bin) {
+        if (typeof pkg.bin === 'string') {
+            files.push(normalizePath(pkg.bin));
+        }
+        if (typeof pkg.bin === 'object' && pkg.bin !== null) {
+            files.push(...Object.values(pkg.bin).map(normalizePath));
+        }
+    }
+    return files;
+}
+
+function isAlwaysIgnored(basename) {
+    if (alwaysIgnored.includes(basename)) {
+        return true;
+    }
+    return alwaysIgnoredPatterns.some(pattern => pattern.test(basename));
+}
+
+async function removeJunkFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (hardIgnored.has(entry.name)) {
+            continue;
+        }
+        const fullPath = path.join(dir, entry.name);
+        if (isAlwaysIgnored(entry.name)) {
+            await rm(fullPath, { recursive: true, force: true });
+        } else if (entry.isDirectory()) {
+            await removeJunkFiles(fullPath);
+        }
+    }
+}
+
+function isAlwaysIncludedByBasename(file) {
+    const dir = path.dirname(file);
+    if (dir !== '' && dir !== '.') {
+        return false;
+    }
+    const basenameWithoutExtension = path.basename(file, path.extname(file)).toUpperCase();
+    return alwaysIncludedBasenames.includes(basenameWithoutExtension);
+}
+
+async function cleanupDir(pkg, logger) {
+    logger.update('cleaning up files...');
+
+    const alwaysIncludedFiles = getAlwaysIncludedFiles(pkg);
+    const filesEntries =  (pkg.files).map(normalizePath);
+
+    const entries = await readdir('.');
+
+    for (const entry of entries) {
+        if (hardIgnored.has(entry)) {
+            continue;
+        }
+
+        const normalized = normalizePath(entry);
+
+        if (filesEntries.some(f => normalized === f || normalized.startsWith(`${f}/`))) {
+            continue;
+        }
+
+        if (filesEntries.some(f => f.startsWith(`${normalized}/`))) {
+
+            await cleanupSubDir(normalized, filesEntries, alwaysIncludedFiles);
+            continue;
+        }
+
+        if (alwaysIncludedFiles.includes(normalized)) {
+            continue;
+        }
+
+        if (isAlwaysIncludedByBasename(normalized)) {
+            continue;
+        }
+
+        await rm(entry, { recursive: true, force: true });
+    }
+
+    pkg.files = undefined;
+}
+
+async function cleanupSubDir(dir, filesEntries, alwaysIncludedFiles) {
+    const entries = await readdir(dir);
+
+    for (const entry of entries) {
+        if (hardIgnored.has(entry)) {
+            continue;
+        }
+
+        const fullPath = path.join(dir, entry);
+
+        const normalized = normalizePath(fullPath);
+
+        if (filesEntries.some(f => normalized === f || normalized.startsWith(`${f}/`))) {
+            continue;
+        }
+
+        if (filesEntries.some(f => f.startsWith(`${normalized}/`))) {
+            await cleanupSubDir(normalized, filesEntries, alwaysIncludedFiles);
+            continue;
+        }
+
+        if (alwaysIncludedFiles.includes(normalized)) {
+            continue;
+        }
+
+        await rm(fullPath, { recursive: true, force: true });
+    }
+
+    const remaining = await readdir(dir);
+    if (remaining.length === 0) {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+
+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,
+    };
+}
+
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+
+const logger = createLogger();
+logger.update('preparing..');
+
+try {
+    const version = await getMyVersion();
+
+    logger.update('');
+    process.stdout.moveCursor?.(0, -1);
+
+    const cliOptions = cli({
+        name: 'pkgprn',
+        version: version ?? '<unknown>',
+        help: {
+            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 (comma-separated for multiple directories)',
+                default: false,
+            },
+            removeSourcemaps: {
+                type: Boolean,
+                description: 'remove sourcemaps',
+                default: false,
+            },
+            stripComments: {
+                type: StripCommentsParam,
+                description: 'strip comments: all (default), jsdoc, license, regular (comma-separated)',
+                default: false,
+            },
+            optimizeFiles: {
+                type: Boolean,
+                description: 'optimize files array',
+                default: true,
+            },
+            cleanupFiles: {
+                type: Boolean,
+                description: 'cleanup files not included in files array',
+                default: true,
+            },
+        },
+    });
+
+    const pkg = await readPackage('.');
+    if (!pkg) {
+        throw new Error('Could not read package.json');
+    }
+    await prunePkg(pkg, cliOptions.flags, logger);
+
+    await writePackage(pkg);
+} catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.finish(`Error: ${errorMessage}`, 3);
+    process.exit(255);
+}
+
+async function getMyVersion() {
+    const pkg = await readPackage(resolve(__dirname$1));
+
+    return pkg && 'version' in pkg && typeof pkg.version === 'string' ? pkg.version : '<unknown>';
+}
+
+async function readPackage(dir) {
+    const packageFileName = resolve(dir, 'package.json');
+    try {
+        const pkgFile = await readFile(packageFileName);
+        return JSON.parse(pkgFile.toString());
+    } catch {
+
+    }
+}
+
+async function writePackage(pkg) {
+    await writeFile('./package.json', `${JSON.stringify(pkg, null, 2)}\n`);
+}
+
+function StripCommentsParam(value) {
+    if (value === '') {
+        return 'all';
+    }
+    return value;
+}
+
+function FlattenParam(value) {
+    if (value === '') {
+        return true;
+    }
+    return value;
+}