@tbela99/css-parser 0.0.1-alpha3

package/dist/lib/parser/utils/config.js

@@ -0,0 +1,5 @@
+import config from '../../../config.json.js';
+
+const getConfig = () => config;
+
+export { getConfig };

package/dist/lib/parser/utils/eq.js

@@ -0,0 +1,13 @@
+function eq(a, b) {
+    if ((typeof a != 'object') || typeof b != 'object') {
+        return a === b;
+    }
+    const k1 = Object.keys(a);
+    const k2 = Object.keys(b);
+    return k1.length == k2.length &&
+        k1.every((key) => {
+            return eq(a[key], b[key]);
+        });
+}
+
+export { eq };

package/dist/lib/parser/utils/syntax.js

@@ -0,0 +1,247 @@
+// https://www.w3.org/TR/CSS21/syndata.html#syntax
+// https://www.w3.org/TR/2021/CRD-css-syntax-3-20211224/#typedef-ident-token
+// '\\'
+const REVERSE_SOLIDUS = 0x5c;
+function isLength(dimension) {
+    return 'unit' in dimension && [
+        'q', 'cap', 'ch', 'cm', 'cqb', 'cqh', 'cqi', 'cqmax', 'cqmin', 'cqw', 'dvb',
+        'dvh', 'dvi', 'dvmax', 'dvmin', 'dvw', 'em', 'ex', 'ic', 'in', 'lh', 'lvb',
+        'lvh', 'lvi', 'lvmax', 'lvw', 'mm', 'pc', 'pt', 'px', 'rem', 'rlh', 'svb',
+        'svh', 'svi', 'svmin', 'svw', 'vb', 'vh', 'vi', 'vmax', 'vmin', 'vw'
+    ].includes(dimension.unit.toLowerCase());
+}
+function isResolution(dimension) {
+    return 'unit' in dimension && ['dpi', 'dpcm', 'dppx', 'x'].includes(dimension.unit.toLowerCase());
+}
+function isAngle(dimension) {
+    return 'unit' in dimension && ['rad', 'turn', 'deg', 'grad'].includes(dimension.unit.toLowerCase());
+}
+function isTime(dimension) {
+    return 'unit' in dimension && ['ms', 's'].includes(dimension.unit.toLowerCase());
+}
+function isFrequency(dimension) {
+    return 'unit' in dimension && ['hz', 'khz'].includes(dimension.unit.toLowerCase());
+}
+function isLetter(codepoint) {
+    // lowercase
+    return (codepoint >= 0x61 && codepoint <= 0x7a) ||
+        // uppercase
+        (codepoint >= 0x41 && codepoint <= 0x5a);
+}
+function isNonAscii(codepoint) {
+    return codepoint >= 0x80;
+}
+function isIdentStart(codepoint) {
+    // _
+    return codepoint == 0x5f || isLetter(codepoint) || isNonAscii(codepoint);
+}
+function isDigit(codepoint) {
+    return codepoint >= 0x30 && codepoint <= 0x39;
+}
+function isIdentCodepoint(codepoint) {
+    // -
+    return codepoint == 0x2d || isDigit(codepoint) || isIdentStart(codepoint);
+}
+function isIdent(name) {
+    const j = name.length - 1;
+    let i = 0;
+    let codepoint = name.charCodeAt(0);
+    // -
+    if (codepoint == 0x2d) {
+        const nextCodepoint = name.charCodeAt(1);
+        if (nextCodepoint == null) {
+            return false;
+        }
+        // -
+        if (nextCodepoint == 0x2d) {
+            return true;
+        }
+        if (nextCodepoint == REVERSE_SOLIDUS) {
+            return name.length > 2 && !isNewLine(name.charCodeAt(2));
+        }
+        return true;
+    }
+    if (!isIdentStart(codepoint)) {
+        return false;
+    }
+    while (i < j) {
+        i += codepoint < 0x80 ? 1 : String.fromCodePoint(codepoint).length;
+        codepoint = name.charCodeAt(i);
+        if (!isIdentCodepoint(codepoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isPseudo(name) {
+    if (name.charAt(0) != ':') {
+        return false;
+    }
+    if (name.endsWith('(')) {
+        return isIdent(name.charAt(1) == ':' ? name.slice(2, -1) : name.slice(1, -1));
+    }
+    return isIdent(name.charAt(1) == ':' ? name.slice(2) : name.slice(1));
+}
+function isHash(name) {
+    if (name.charAt(0) != '#') {
+        return false;
+    }
+    if (isIdent(name.charAt(1))) {
+        return true;
+    }
+    return true;
+}
+function isNumber(name) {
+    if (name.length == 0) {
+        return false;
+    }
+    let codepoint = name.charCodeAt(0);
+    let i = 0;
+    const j = name.length;
+    // '+' '-'
+    if ([0x2b, 0x2d].includes(codepoint)) {
+        i++;
+    }
+    // consume digits
+    while (i < j) {
+        codepoint = name.charCodeAt(i);
+        if (isDigit(codepoint)) {
+            i++;
+            continue;
+        }
+        // '.' 'E' 'e'
+        if (codepoint == 0x2e || codepoint == 0x45 || codepoint == 0x65) {
+            break;
+        }
+        return false;
+    }
+    // '.'
+    if (codepoint == 0x2e) {
+        if (!isDigit(name.charCodeAt(++i))) {
+            return false;
+        }
+    }
+    while (i < j) {
+        codepoint = name.charCodeAt(i);
+        if (isDigit(codepoint)) {
+            i++;
+            continue;
+        }
+        // 'E' 'e'
+        if (codepoint == 0x45 || codepoint == 0x65) {
+            i++;
+            break;
+        }
+        return false;
+    }
+    // 'E' 'e'
+    if (codepoint == 0x45 || codepoint == 0x65) {
+        if (i == j) {
+            return false;
+        }
+        codepoint = name.charCodeAt(i + 1);
+        // '+' '-'
+        if ([0x2b, 0x2d].includes(codepoint)) {
+            i++;
+        }
+        codepoint = name.charCodeAt(i + 1);
+        if (!isDigit(codepoint)) {
+            return false;
+        }
+    }
+    while (++i < j) {
+        codepoint = name.charCodeAt(i);
+        if (!isDigit(codepoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDimension(name) {
+    let index = 0;
+    while (index++ < name.length) {
+        if (isDigit(name.charCodeAt(name.length - index))) {
+            index--;
+            break;
+        }
+        if (index == 3) {
+            break;
+        }
+    }
+    if (index == 0 || index > 3) {
+        return false;
+    }
+    const number = name.slice(0, -index);
+    return number.length > 0 && isIdentStart(name.charCodeAt(name.length - index)) && isNumber(number);
+}
+function isPercentage(name) {
+    return name.endsWith('%') && isNumber(name.slice(0, -1));
+}
+function parseDimension(name) {
+    let index = 0;
+    while (index++ < name.length) {
+        if (isDigit(name.charCodeAt(name.length - index))) {
+            index--;
+            break;
+        }
+        if (index == 3) {
+            break;
+        }
+    }
+    const dimension = { typ: 'Dimension', val: name.slice(0, -index), unit: name.slice(-index) };
+    if (isAngle(dimension)) {
+        // @ts-ignore
+        dimension.typ = 'Angle';
+    }
+    else if (isLength(dimension)) {
+        // @ts-ignore
+        dimension.typ = 'Length';
+    }
+    else if (isTime(dimension)) {
+        // @ts-ignore
+        dimension.typ = 'Time';
+    }
+    else if (isResolution(dimension)) {
+        // @ts-ignore
+        dimension.typ = 'Resolution';
+        if (dimension.unit == 'dppx') {
+            dimension.unit = 'x';
+        }
+    }
+    else if (isFrequency(dimension)) {
+        // @ts-ignore
+        dimension.typ = 'Frequency';
+    }
+    return dimension;
+}
+function isHexColor(name) {
+    if (name.charAt(0) != '#' || ![4, 5, 7, 9].includes(name.length)) {
+        return false;
+    }
+    for (let chr of name.slice(1)) {
+        let codepoint = chr.charCodeAt(0);
+        if (!isDigit(codepoint) &&
+            // A-F
+            !(codepoint >= 0x41 && codepoint <= 0x46) &&
+            // a-f
+            !(codepoint >= 0x61 && codepoint <= 0x66)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isFunction(name) {
+    return name.endsWith('(') && isIdent(name.slice(0, -1));
+}
+function isAtKeyword(name) {
+    return name.charCodeAt(0) == 0x40 && isIdent(name.slice(1));
+}
+function isNewLine(codepoint) {
+    // \n \r \f
+    return codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
+}
+function isWhiteSpace(codepoint) {
+    return codepoint == 0x9 || codepoint == 0x20 || isNewLine(codepoint);
+}
+
+export { isAngle, isAtKeyword, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension };

package/dist/lib/parser/utils/type.js

@@ -0,0 +1,12 @@
+function matchType(val, properties) {
+    if (val.typ == 'Iden' && properties.keywords.includes(val.val) ||
+        (properties.types.includes(val.typ))) {
+        return true;
+    }
+    if (val.typ == 'Number' && val.val == '0') {
+        return properties.types.some(type => type == 'Length' || type == 'Angle');
+    }
+    return false;
+}
+
+export { matchType };

package/dist/lib/renderer/render.js

@@ -0,0 +1,242 @@
+import { rgb2Hex, hsl2Hex, hwb2hex, cmyk2hex, NAMES_COLORS } from './utils/color.js';
+
+const indents = [];
+function render(data, opt = {}) {
+    const options = Object.assign(opt.compress ? {
+        indent: '',
+        newLine: '',
+        removeComments: true
+    } : {
+        indent: ' ',
+        newLine: '\n',
+        compress: false,
+        removeComments: false,
+    }, { colorConvert: true, preserveLicense: false }, opt);
+    function reducer(acc, curr, index, original) {
+        if (curr.typ == 'Comment' && options.removeComments) {
+            if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
+                return acc;
+            }
+        }
+        if (options.compress && curr.typ == 'Whitespace') {
+            if (original[index + 1]?.typ == 'Start-parens' ||
+                (index > 0 && (original[index - 1].typ == 'Pseudo-class-func' ||
+                    original[index - 1].typ == 'End-parens' ||
+                    original[index - 1].typ == 'UrlFunc' ||
+                    original[index - 1].typ == 'Func' ||
+                    (original[index - 1].typ == 'Color' &&
+                        original[index - 1].kin != 'hex' &&
+                        original[index - 1].kin != 'lit')))) {
+                return acc;
+            }
+        }
+        return acc + renderToken(curr, options);
+    }
+    return { code: doRender(data, options, reducer) };
+}
+// @ts-ignore
+function doRender(data, options, reducer, level = 0) {
+    if (indents.length < level + 1) {
+        indents.push(options.indent.repeat(level));
+    }
+    if (indents.length < level + 2) {
+        indents.push(options.indent.repeat(level + 1));
+    }
+    const indent = indents[level];
+    const indentSub = indents[level + 1];
+    switch (data.typ) {
+        case 'Comment':
+            return options.removeComments ? '' : data.val;
+        case 'StyleSheet':
+            return data.chi.reduce((css, node) => {
+                const str = doRender(node, options, reducer, level);
+                if (str === '') {
+                    return css;
+                }
+                if (css === '') {
+                    return str;
+                }
+                return `${css}${options.newLine}${str}`;
+            }, '');
+        case 'AtRule':
+        case 'Rule':
+            if (data.typ == 'AtRule' && !('chi' in data)) {
+                return `${indent}@${data.nam} ${data.val};`;
+            }
+            // @ts-ignore
+            let children = data.chi.reduce((css, node) => {
+                let str;
+                if (node.typ == 'Comment') {
+                    str = options.removeComments ? '' : node.val;
+                }
+                else if (node.typ == 'Declaration') {
+                    str = `${node.nam}:${options.indent}${node.val.reduce(reducer, '').trimEnd()};`;
+                }
+                else if (node.typ == 'AtRule' && !('chi' in node)) {
+                    str = `@${node.nam} ${node.val};`;
+                }
+                else {
+                    str = doRender(node, options, reducer, level + 1);
+                }
+                if (css === '') {
+                    return str;
+                }
+                if (str === '') {
+                    return css;
+                }
+                if (str !== '')
+                    return `${css}${options.newLine}${indentSub}${str}`;
+            }, '');
+            if (children.endsWith(';')) {
+                children = children.slice(0, -1);
+            }
+            if (data.typ == 'AtRule') {
+                return `@${data.nam}${data.val ? ' ' + data.val + options.indent : ''}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
+            }
+            return data.sel + `${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
+    }
+    return '';
+}
+function renderToken(token, options = {}) {
+    switch (token.typ) {
+        case 'Color':
+            if (options.compress || options.colorConvert) {
+                let value = token.kin == 'hex' ? token.val.toLowerCase() : '';
+                if (token.val == 'rgb' || token.val == 'rgba') {
+                    value = rgb2Hex(token);
+                }
+                else if (token.val == 'hsl' || token.val == 'hsla') {
+                    value = hsl2Hex(token);
+                }
+                else if (token.val == 'hwb') {
+                    value = hwb2hex(token);
+                }
+                else if (token.val == 'device-cmyk') {
+                    value = cmyk2hex(token);
+                }
+                const named_color = NAMES_COLORS[value];
+                if (value !== '') {
+                    if (value.length == 7) {
+                        if (value[1] == value[2] &&
+                            value[3] == value[4] &&
+                            value[5] == value[6]) {
+                            value = `#${value[1]}${value[3]}${value[5]}`;
+                        }
+                    }
+                    else if (value.length == 9) {
+                        if (value[1] == value[2] &&
+                            value[3] == value[4] &&
+                            value[5] == value[6] &&
+                            value[7] == value[8]) {
+                            value = `#${value[1]}${value[3]}${value[5]}${value[7]}`;
+                        }
+                    }
+                    return named_color != null && named_color.length <= value.length ? named_color : value;
+                }
+            }
+            if (token.kin == 'hex' || token.kin == 'lit') {
+                return token.val;
+            }
+        case 'Func':
+        case 'UrlFunc':
+        case 'Pseudo-class-func':
+            // @ts-ignore
+            return (options.compress && 'Pseudo-class-func' == token.typ && token.val.slice(0, 2) == '::' ? token.val.slice(1) : token.val) + '(' + token.chi.reduce((acc, curr) => {
+                if (options.removeComments && curr.typ == 'Comment') {
+                    if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
+                        return acc;
+                    }
+                }
+                return acc + renderToken(curr, options);
+            }, '') + ')';
+        case 'Includes':
+            return '~=';
+        case 'Dash-match':
+            return '|=';
+        case 'Lt':
+            return '<';
+        case 'Gt':
+            return '>';
+        case 'Start-parens':
+            return '(';
+        case 'End-parens':
+            return ')';
+        case 'Attr-start':
+            return '[';
+        case 'Attr-end':
+            return ']';
+        case 'Whitespace':
+            return ' ';
+        case 'Colon':
+            return ':';
+        case 'Semi-colon':
+            return ';';
+        case 'Comma':
+            return ',';
+        case 'Important':
+            return '!important';
+        case 'Attr':
+            return '[' + token.chi.reduce((acc, curr) => acc + renderToken(curr, options), '') + ']';
+        case 'Time':
+        case 'Frequency':
+        case 'Angle':
+        case 'Length':
+        case 'Dimension':
+            const val = (+token.val).toString();
+            if (val === '0') {
+                if (token.typ == 'Time') {
+                    return '0s';
+                }
+                if (token.typ == 'Frequency') {
+                    return '0Hz';
+                }
+                // @ts-ignore
+                if (token.typ == 'Resolution') {
+                    return '0x';
+                }
+                return '0';
+            }
+            const chr = val.charAt(0);
+            if (chr == '-') {
+                const slice = val.slice(0, 2);
+                if (slice == '-0') {
+                    return (val.length == 2 ? '0' : '-' + val.slice(2)) + token.unit;
+                }
+            }
+            else if (chr == '0') {
+                return val.slice(1) + token.unit;
+            }
+            return val + token.unit;
+        case 'Perc':
+            return token.val + '%';
+        case 'Number':
+            const num = (+token.val).toString();
+            if (token.val.length < num.length) {
+                return token.val;
+            }
+            if (num.charAt(0) === '0' && num.length > 1) {
+                return num.slice(1);
+            }
+            const slice = num.slice(0, 2);
+            if (slice == '-0') {
+                return '-' + num.slice(2);
+            }
+            return num;
+        case 'Comment':
+            if (options.removeComments) {
+                return '';
+            }
+        case 'Url-token':
+        case 'At-rule':
+        case 'Hash':
+        case 'Pseudo-class':
+        case 'Literal':
+        case 'String':
+        case 'Iden':
+        case 'Delim':
+            return options.compress && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) : token.val;
+    }
+    throw new Error(`unexpected token ${JSON.stringify(token, null, 1)}`);
+}
+
+export { render, renderToken };