pkgprn 0.5.0 → 0.5.2

package/strip-comments.js

@@ -0,0 +1,496 @@
+import { decode, encode } from '@jridgewell/sourcemap-codec';
+
+const jsExtensions = ['.js', '.mjs', '.cjs'];
+
+export 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';
+}
+
+export 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, comments);
+            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, comments);
+                    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) {
+    void 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;
+}
+
+export 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;
+}
+
+export function stripComments(source, typesToStrip) {
+    return stripCommentsWithLineMap(source, typesToStrip).result;
+}
+
+export 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;
+}
+
+export 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);
+}