@pi-r/chrome 0.11.3 → 0.12.0

package/extensions/css/remove-unused/index.js

@@ -0,0 +1,423 @@
+"use strict";
+
+const { randomUUID } = require('node:crypto');
+const Document = require('@e-mc/document');
+const { DomWriter } = require('@e-mc/document/parse/dom');
+const { escapePattern } = require('@e-mc/types');
+const { PATTERN_PARENTHESIS, findClosingIndex, getNewlineString, replaceMatch, spliceSource, splitEnclosing } = require('@pi-r/chrome/util');
+const PATTERN_STRING_SOME = '(?:\\s|' + DomWriter.PATTERN_COMMENT + '|`[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}`)*';
+const PATTERN_STRING_MANY = PATTERN_STRING_SOME.slice(0, -1) + '+';
+const PATTERN_VARIABLE = '--(?:[-\\w]+|\\\\\\S|[^\\u0000-\\u007F]+)+';
+const CACHE_ATRULES = Object.create(null);
+const CACHE_QUERY = new Map();
+const CACHE_SELECTOR = new Map();
+const REGEXP_COMMENT = new RegExp(DomWriter.PATTERN_COMMENT, 'g');
+const REGEXP_QUOTEDVALUE = new RegExp(`\\b(?:@import${PATTERN_STRING_MANY}|content${PATTERN_STRING_SOME}:${PATTERN_STRING_SOME})(?:"[^"]*"|'[^']*')`, 'gi');
+const REGEXP_VARIABLES = new RegExp(`(?<!style\\()(\\s*)(${PATTERN_VARIABLE})${PATTERN_STRING_SOME}:[^;}]*([;}])` + DomWriter.PATTERN_TRAILINGSPACE, 'g');
+const REGEXP_FONTFACE = new RegExp(`(\\s*)@font-face${PATTERN_STRING_SOME}{([^}]+)}` + DomWriter.PATTERN_TRAILINGSPACE, 'gi');
+const REGEXP_FONTFAMILY = new RegExp(`\\bfont-family${PATTERN_STRING_SOME}:([^;}]+)`, 'i');
+const REGEXP_KEYFRAMES = new RegExp(`(\\s*)@keyframes${PATTERN_STRING_MANY}([^{]+){`, 'gi');
+const REGEXP_PROPERTY = new RegExp(`(\\s*)@property${PATTERN_STRING_MANY}(${PATTERN_VARIABLE})${PATTERN_STRING_SOME}{`, 'gi');
+const REGEXP_NTHCHILD = new RegExp(`\\(${PATTERN_STRING_SOME}([+-])?(?:(\\d*)[nN]|(0))?${PATTERN_STRING_SOME}([+-])?${PATTERN_STRING_SOME}(\\d*)(?:${PATTERN_STRING_MANY}[oO][fF]${PATTERN_STRING_MANY}(${PATTERN_PARENTHESIS})${PATTERN_STRING_SOME}\\)|${PATTERN_STRING_SOME}\\))`, 'g');
+const REGEXP_LEADINGBRACE = new RegExp(`(.)${PATTERN_STRING_SOME}{$`);
+const REGEXP_VARIABLES_UNSAFE = new RegExp(`(?<!style\\()(\\s*)(--[^\\s:]+)\\s*:[^;}]*([;}])` + DomWriter.PATTERN_TRAILINGSPACE, 'g');
+const REGEXP_FONTFACE_UNSAFE = new RegExp(`(\\s*)@font-face\\s*{([^}]+)}` + DomWriter.PATTERN_TRAILINGSPACE, 'gi');
+const REGEXP_FONTFAMILY_UNSAFE = /\bfont-family\s*:([^;}]+)/i;
+const REGEXP_KEYFRAMES_UNSAFE = /(\s*)@keyframes\s+([^{]+){/gi;
+const REGEXP_PROPERTY_UNSAFE = /(\s*)@property\s+(--\S+)\s*{/gi;
+const REGEXP_NTHCHILD_UNSAFE = new RegExp(`\\(\\s*([+-])?(?:(\\d*)[nN]|(0))?\\s*([+-])?\\s*(\\d*)(?:\\s+[oO][fF]\\s+(${PATTERN_PARENTHESIS})\\s*\\)|\\s*\\))`, 'g');
+const REGEXP_LEADINGBRACE_UNSAFE = /(.)\s*{$/;
+const getEndIndex = (match) => match.index + match[0].length;
+function cssUnused(source, options) {
+    const { usedVariables, usedFontFace, usedKeyframes, unusedStyles, unusedMedia, unusedSupports, unusedContainer, unusedScope, useUnsafeCssReplace, useSessionCache } = options.config;
+    if (!usedVariables && !usedFontFace && !usedKeyframes && !unusedStyles && !unusedMedia && !unusedSupports && !unusedContainer && !unusedScope) {
+        return;
+    }
+    const [stringSome, stringMany] = useUnsafeCssReplace ? ['\\s*', '\\s+'] : [PATTERN_STRING_SOME, PATTERN_STRING_MANY];
+    const replaceMap = [];
+    let current = source, modified = false, checkEmpty, match;
+    const parseSelector = (value) => {
+        const items = [];
+        const revised = value.replace(useUnsafeCssReplace ? REGEXP_NTHCHILD_UNSAFE : REGEXP_NTHCHILD, (...capture) => {
+            return '`%' + (items.push('\\(' + stringSome + (capture[1] === '-' ? '\\x2d' : '\\x2b?') + (capture[2] || '[01]?') + (capture[3] === '0' ? !capture[1] && !capture[2] && !capture[4] && !capture[5] ? '[+-]?0[nN]?' : '0' : '[nN]?') + stringSome + (capture[5] ? (capture[4] === '-' ? '\\x2d' : '\\x2b?') + stringSome + capture[5] : `(?:[+-]${stringSome}0)?`) + (capture[6] ? stringMany + '[oO][fF]' + stringMany + capture[6].trim() : '') + stringSome + '\\)') - 1) + '`';
+        });
+        let selector = '';
+        for (let i = 0, length = revised.length, casing = false, attr = false, quote = false; i < length; i++) {
+            let ch = revised[i], space = 0;
+            switch (ch) {
+                case '.':
+                case '#':
+                    if (!attr) {
+                        casing = true;
+                    }
+                    break;
+                case '[':
+                    if (!quote) {
+                        attr = true;
+                        casing = false;
+                        space = 2;
+                    }
+                    break;
+                case ']':
+                    if (!quote || attr && revised[i - 1] === '"' && revised[i - 2] === '\\') {
+                        if (quote) {
+                            selector = selector.slice(0, -1) + '`%%%`';
+                            quote = false;
+                        }
+                        attr = false;
+                        casing = false;
+                        space = 1;
+                    }
+                    break;
+                case '=':
+                    if (attr && !quote) {
+                        casing = true;
+                        space = 3;
+                    }
+                    break;
+                case '\\':
+                    ch = '`%%%%`';
+                    break;
+                case '"':
+                    if (attr) {
+                        if (!quote) {
+                            ch = '`%%%`';
+                            quote = true;
+                        }
+                        else if (revised[i - 1] !== '\\') {
+                            ch = '`%%%`';
+                            quote = false;
+                            casing = false;
+                        }
+                    }
+                    break;
+                case '~':
+                case '^':
+                case '$':
+                case '*':
+                case '|':
+                    if (attr && !quote) {
+                        space = 1;
+                    }
+                    break;
+                case ' ':
+                    if (attr && !quote) {
+                        ch = '`%%`';
+                        break;
+                    }
+                case ':':
+                case ',':
+                    if (!attr) {
+                        casing = false;
+                    }
+                    break;
+            }
+            selector += (space & 1 ? '`%%`' : '') + (!casing && ch >= 'a' && ch <= 'z' ? '`' + ch + ch.toUpperCase() + '`' : ch) + (space & 2 ? '`%%`' : '');
+        }
+        selector = escapePattern(selector)
+            .replace(/\s*(>|~(?!=)|\\\+|\\\*(?!=)])\s*/g, (...capture) => stringSome + capture[1] + stringSome)
+            .replace(/`([a-z][A-Z]|%{2,4})`/g, (...capture) => {
+            switch (capture[1]) {
+                case '%%':
+                    return stringSome;
+                case '%%%':
+                    return `(?:["']|${stringSome})`;
+                case '%%%%':
+                    return '\\\\{0,}';
+                default:
+                    return `[${capture[1]}]`;
+            }
+        });
+        for (let i = 0, length = revised.length; i < length; ++i) {
+            selector = selector.replace('`%' + i + '`', items[i]);
+        }
+        return selector.replace(/ +/g, stringMany) + stringSome;
+    };
+    const replaceUnunsed = (name, items, nesting, increment = 1) => {
+        for (let i = 0; i < items.length; i += increment) {
+            const value = items[i].trim();
+            let valueTo;
+            const key = name + '_' + value + (increment === 2 && (valueTo = items[i + 1].trim()) ? '_' + valueTo : '') + (useUnsafeCssReplace ? '_1' : '');
+            let pattern = CACHE_QUERY.get(key), rule;
+            if (!pattern) {
+                let flags = 'gi', selector = '', revised = false;
+                if (name === 'container') {
+                    for (let j = 0, length = value.length, casing = true; j < length; j++) {
+                        let ch = value[j];
+                        if (!casing) {
+                            ch = ch.toLowerCase();
+                        }
+                        else if (ch === '(') {
+                            casing = false;
+                        }
+                        if (casing || ch < 'a' || ch > 'z') {
+                            selector += value[j];
+                            if (selector.endsWith(' not ')) {
+                                selector = selector.replace(/ not $/, ' `nN``oO``tT` ');
+                            }
+                        }
+                        else {
+                            selector += '`' + ch + ch.toUpperCase() + '`';
+                        }
+                    }
+                    flags = 'g';
+                }
+                else if (name === 'scope') {
+                    selector = `\\(${stringSome + parseSelector(value)}\\)`;
+                    if (valueTo) {
+                        selector += `${stringMany}[tT][oO]${stringMany}\\(${stringSome + parseSelector(valueTo)}\\)`;
+                    }
+                    flags = 'g';
+                    revised = true;
+                }
+                else if (name === 'supports' && /^selector\(/i.test(value)) {
+                    const startIndex = value.indexOf('(');
+                    const endIndex = value.lastIndexOf(')');
+                    if (startIndex !== -1 && endIndex !== -1) {
+                        selector = '[sS][eE][lL][eE][cC][tT][oO][rR]\\(' + stringSome + parseSelector(value.slice(startIndex + 1, endIndex)) + '\\)';
+                        flags = 'g';
+                        revised = true;
+                    }
+                }
+                if (!revised) {
+                    selector = escapePattern(selector || value)
+                        .replace(/\s*(\\[()])\s*/g, (...capture) => stringSome + capture[1] + stringSome)
+                        .replace(/:\s+/g, stringSome + ':' + stringSome)
+                        .replace(/\s+([<>/]|<=|>=|\\\*)\s+/g, (...capture) => stringSome + capture[1] + stringSome)
+                        .replace(/ +/g, stringMany);
+                    if (flags === 'g') {
+                        selector = selector.replace(/`([a-z][A-Z])`/g, (...capture) => `[${capture[1]}]`);
+                    }
+                }
+                pattern = new RegExp('(\\s*)@' + (flags === 'g' ? name.split('').map(ch => `[${ch + ch.toUpperCase()}]`).join('') : name) + stringMany + selector + stringSome + '{', flags);
+                if (useSessionCache !== false) {
+                    CACHE_QUERY.set(key, pattern);
+                }
+            }
+            else {
+                pattern.lastIndex = 0;
+            }
+            while (rule = pattern.exec(current)) {
+                if (!nesting) {
+                    const block = Array.from(current.slice(0, rule.index).matchAll(/[{}]/g));
+                    if (block.filter(open => open[0] === '{').length !== block.filter(close => close[0] === '}').length) {
+                        continue;
+                    }
+                }
+                const [endIndex, trailing] = findClosingIndex(current, getEndIndex(rule), '{');
+                if (endIndex !== -1) {
+                    current = spliceSource(current, rule.index, endIndex, pattern, rule[1], trailing);
+                    (checkEmpty ||= {})[name] = true;
+                    modified = true;
+                }
+            }
+        }
+    };
+    if (!useUnsafeCssReplace) {
+        const replaceBracket = (pattern) => {
+            let bracket;
+            while (bracket = pattern.exec(current)) {
+                const segment = bracket[0];
+                if (/[{}]/.test(segment)) {
+                    const placeholder = '`' + randomUUID().slice(0, 18) + '`';
+                    replaceMap.push([placeholder, segment]);
+                    current = replaceMatch(bracket, current, placeholder, pattern);
+                }
+            }
+            pattern.lastIndex = 0;
+        };
+        replaceBracket(REGEXP_COMMENT);
+        replaceBracket(REGEXP_QUOTEDVALUE);
+        const values = splitEnclosing(current, /\b(?<!-)url/gi);
+        for (let i = 0, length = values.length; i < length; ++i) {
+            const seg = values[i];
+            if (/^url\([^{}]*[{}].*\)$/is.test(seg)) {
+                replaceMap.push([values[i] = randomUUID().slice(0, 18), seg]);
+            }
+        }
+        if (replaceMap.length > 0) {
+            current = values.join('');
+        }
+    }
+    if (unusedMedia) {
+        replaceUnunsed('media', unusedMedia, true);
+    }
+    if (unusedSupports) {
+        replaceUnunsed('supports', unusedSupports, true);
+    }
+    if (unusedContainer) {
+        replaceUnunsed('container', unusedContainer, false);
+    }
+    if (unusedScope) {
+        replaceUnunsed('scope', unusedScope.map(item => [item.start || '', item.end || '']).flat(), false, 2);
+    }
+    if (unusedStyles) {
+        current = (function recurse(target, child) {
+            let output = '', index = 0, pendingStart = 0, pendingEnd = 0, found = -1;
+            while ((found = target.indexOf('{', index)) !== -1) {
+                ++found;
+                const closing = findClosingIndex(target, found, '{')[0];
+                if (closing === -1) {
+                    break;
+                }
+                let header = target.slice(index, found), invalid = 0, content;
+                for (const value of unusedStyles) {
+                    const key = value + (child ? '_1' : '') + (useUnsafeCssReplace ? '_2' : '');
+                    const pattern = CACHE_SELECTOR.get(key);
+                    let single, group;
+                    if (!pattern) {
+                        const selector = parseSelector(value) + (child ? `(?:${stringSome}&${stringSome})*` : '');
+                        single = new RegExp(`(^|;)(${stringSome})(?<!${child ? '&|' : ''}@[^};]*)${selector}\\{$`);
+                        group = new RegExp(`((?:^|;)[^{]*${stringSome}(,${stringSome}|(?<!@[^};]*)))(${(child ? '(?:&\\s+|(?<!&))' : '') + selector})(,[^{]*)?\\{$`, 'g');
+                        if (useSessionCache !== false) {
+                            CACHE_SELECTOR.set(key, [single, group]);
+                        }
+                    }
+                    else {
+                        [single, group] = pattern;
+                    }
+                    if (match = single.exec(header)) {
+                        content = match[1] === ';' ? header.slice(0, match.index + 1) + match[2].replace(/[^\n]+$/, '') : undefined;
+                        invalid = 1;
+                        break;
+                    }
+                    let leading = -1, first = true;
+                    while (match = group.exec(header)) {
+                        const start = match.index + match[1].length;
+                        if (!child && first) {
+                            if (match[1].trimEnd().endsWith(';')) {
+                                leading = start;
+                            }
+                            first = false;
+                        }
+                        const sibling = match[2].startsWith(',');
+                        const trailing = match[4];
+                        const offset = trailing && !sibling ? /^,\s*/.exec(trailing)[0].length : 1;
+                        header = header.slice(0, start - (sibling ? match[2].length : 0)) + header.slice(start + match[3].length + (trailing ? sibling ? 0 : offset : /\s$/.test(match[3]) ? -1 : 0));
+                        group.lastIndex = match.index;
+                        invalid = 2;
+                    }
+                    if (invalid) {
+                        group.lastIndex = 0;
+                        const empty = (useUnsafeCssReplace ? REGEXP_LEADINGBRACE_UNSAFE : REGEXP_LEADINGBRACE).exec(header);
+                        if (empty) {
+                            if (header.trim() === '{') {
+                                content = undefined;
+                                invalid = 1;
+                                break;
+                            }
+                            if (leading !== -1 && empty[1] === ';') {
+                                content = target.slice(index, found).slice(0, leading).replace(/[^\n;]+$/, '');
+                                invalid = 1;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (invalid === 0 || invalid === 2) {
+                    const trailing = target.slice(found, closing);
+                    if (content = recurse(trailing, true)) {
+                        content = header + content;
+                    }
+                    else if (invalid === 2) {
+                        content = header + trailing;
+                    }
+                }
+                if (content) {
+                    if (pendingEnd) {
+                        output = target.slice(pendingStart, pendingEnd) + content;
+                        pendingEnd = 0;
+                    }
+                    else {
+                        output += content;
+                    }
+                }
+                else if (!invalid) {
+                    if (output) {
+                        output += target.slice(index, closing);
+                    }
+                    else {
+                        pendingEnd = closing;
+                    }
+                }
+                else if (pendingEnd) {
+                    output = target.slice(pendingStart, pendingEnd);
+                    pendingEnd = 0;
+                }
+                else {
+                    pendingStart = closing;
+                }
+                index = closing;
+            }
+            if (output) {
+                modified = true;
+                return output + target.slice(index);
+            }
+            return child ? '' : target;
+        })(current, false);
+    }
+    if (usedVariables) {
+        let pattern = useUnsafeCssReplace ? REGEXP_VARIABLES_UNSAFE : REGEXP_VARIABLES;
+        while (match = pattern.exec(current)) {
+            if (!usedVariables.includes(match[2])) {
+                current = replaceMatch(match, current, match[3] === ';' ? getNewlineString(match[1], match[4]) : '', pattern);
+                modified = true;
+            }
+        }
+        pattern.lastIndex = 0;
+        pattern = useUnsafeCssReplace ? REGEXP_PROPERTY_UNSAFE : REGEXP_PROPERTY;
+        while (match = pattern.exec(current)) {
+            if (!usedVariables.includes(match[2])) {
+                const [endIndex, trailing] = findClosingIndex(current, getEndIndex(match), '{');
+                if (endIndex !== -1) {
+                    current = spliceSource(current, match.index, endIndex, pattern, match[1], trailing);
+                    modified = true;
+                }
+            }
+        }
+        pattern.lastIndex = 0;
+    }
+    if (usedFontFace) {
+        const pattern = useUnsafeCssReplace ? REGEXP_FONTFACE_UNSAFE : REGEXP_FONTFACE;
+        const fontFamily = useUnsafeCssReplace ? REGEXP_FONTFAMILY_UNSAFE : REGEXP_FONTFAMILY;
+        while (match = pattern.exec(current)) {
+            const font = fontFamily.exec(match[0]);
+            if (font && !usedFontFace.includes(font[1].trim().replace(/^(["'])(.+)\1$/s, (...content) => content[2]))) {
+                current = spliceSource(current, match.index, getEndIndex(match), pattern, match[1], match[3]);
+                modified = true;
+            }
+        }
+        pattern.lastIndex = 0;
+    }
+    if (usedKeyframes) {
+        const pattern = useUnsafeCssReplace ? REGEXP_KEYFRAMES_UNSAFE : REGEXP_KEYFRAMES;
+        while (match = pattern.exec(current)) {
+            if (!usedKeyframes.includes(match[2].trim())) {
+                const [endIndex, trailing] = findClosingIndex(current, getEndIndex(match), '{');
+                if (endIndex !== -1) {
+                    current = spliceSource(current, match.index, endIndex, pattern, match[1], trailing);
+                    modified = true;
+                }
+            }
+        }
+        pattern.lastIndex = 0;
+    }
+    if (modified) {
+        for (const name in checkEmpty) {
+            const pattern = CACHE_ATRULES[name + (useUnsafeCssReplace ? '_1' : '')] ||= new RegExp(`(\\s*)@${name}[^{]*{${stringSome}}` + DomWriter.PATTERN_TRAILINGSPACE, 'gi');
+            while (match = pattern.exec(current)) {
+                current = spliceSource(current, match.index, getEndIndex(match), pattern, match[1], match[2]);
+            }
+            pattern.lastIndex = 0;
+        }
+        if (replaceMap.length > 0) {
+            for (const [placeholder, content] of replaceMap.reverse()) {
+                current = current.replace(placeholder, content);
+            }
+        }
+        return current;
+    }
+}
+var index = Document.signExtensionType(cssUnused, 'css');
+
+module.exports = index;

package/index.d.ts

@@ -2,6 +2,6 @@ import type { IFileManager } from '@e-mc/types/lib';
 
 import type { ChromeDocumentConstructor, DocumentAsset } from './types';
 
-declare const Chrome: ChromeDocumentConstructor<IFileManager<DocumentAsset>>;
+declare const Chrome: ChromeDocumentConstructor<IFileManager, DocumentAsset>;
 
 export = Chrome;