@tbela99/css-parser 0.0.1-alpha4 → 0.0.1-rc1

package/dist/lib/parser/tokenize.js

@@ -0,0 +1,452 @@
+import { isWhiteSpace, isDigit, isNewLine } from './utils/syntax.js';
+
+function* tokenize(iterator) {
+    let ind = -1;
+    let lin = 1;
+    let col = 0;
+    const position = {
+        ind: Math.max(ind, 0),
+        lin: lin,
+        col: Math.max(col, 1)
+    };
+    let value;
+    let buffer = '';
+    function consumeWhiteSpace() {
+        let count = 0;
+        while (isWhiteSpace(iterator.charAt(count + ind + 1).charCodeAt(0))) {
+            count++;
+        }
+        next(count);
+        return count;
+    }
+    function pushToken(token, hint) {
+        const result = { token, hint, position: { ...position }, bytesIn: ind };
+        position.ind = ind;
+        position.lin = lin;
+        position.col = col == 0 ? 1 : col;
+        return result;
+    }
+    function* consumeString(quoteStr) {
+        const quote = quoteStr;
+        let value;
+        let hasNewLine = false;
+        if (buffer.length > 0) {
+            yield pushToken(buffer);
+            buffer = '';
+        }
+        buffer += quoteStr;
+        while (value = peek()) {
+            if (ind >= iterator.length) {
+                yield pushToken(buffer, hasNewLine ? 'Bad-string' : 'Unclosed-string');
+                break;
+            }
+            if (value == '\\') {
+                const sequence = peek(6);
+                let escapeSequence = '';
+                let codepoint;
+                let i;
+                for (i = 1; i < sequence.length; i++) {
+                    codepoint = sequence.charCodeAt(i);
+                    if (codepoint == 0x20 ||
+                        (codepoint >= 0x61 && codepoint <= 0x66) ||
+                        (codepoint >= 0x41 && codepoint <= 0x46) ||
+                        (codepoint >= 0x30 && codepoint <= 0x39)) {
+                        escapeSequence += sequence[i];
+                        if (codepoint == 0x20) {
+                            break;
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                // not hex or new line
+                // @ts-ignore
+                if (i == 1 && !isNewLine(codepoint)) {
+                    buffer += sequence[i];
+                    next(2);
+                    continue;
+                }
+                if (escapeSequence.trimEnd().length > 0) {
+                    const codepoint = Number(`0x${escapeSequence.trimEnd()}`);
+                    if (codepoint == 0 ||
+                        // leading surrogate
+                        (0xD800 <= codepoint && codepoint <= 0xDBFF) ||
+                        // trailing surrogate
+                        (0xDC00 <= codepoint && codepoint <= 0xDFFF)) {
+                        buffer += String.fromCodePoint(0xFFFD);
+                    }
+                    else {
+                        buffer += String.fromCodePoint(codepoint);
+                    }
+                    next(escapeSequence.length + 1);
+                    continue;
+                }
+                // buffer += value;
+                if (ind >= iterator.length) {
+                    // drop '\\' at the end
+                    yield pushToken(buffer);
+                    break;
+                }
+                buffer += next(2);
+                continue;
+            }
+            if (value == quote) {
+                buffer += value;
+                yield pushToken(buffer, hasNewLine ? 'Bad-string' : 'String');
+                next();
+                // i += value.length;
+                buffer = '';
+                break;
+            }
+            if (isNewLine(value.charCodeAt(0))) {
+                hasNewLine = true;
+            }
+            if (hasNewLine && value == ';') {
+                yield pushToken(buffer, 'Bad-string');
+                buffer = '';
+                break;
+            }
+            buffer += value;
+            // i += value.length;
+            next();
+        }
+    }
+    function peek(count = 1) {
+        if (count == 1) {
+            return iterator.charAt(ind + 1);
+        }
+        return iterator.slice(ind + 1, ind + count + 1);
+    }
+    function prev(count = 1) {
+        if (count == 1) {
+            return ind == 0 ? '' : iterator.charAt(ind - 1);
+        }
+        return iterator.slice(ind - 1 - count, ind - 1);
+    }
+    function next(count = 1) {
+        let char = '';
+        while (count-- > 0 && ind < iterator.length) {
+            const codepoint = iterator.charCodeAt(++ind);
+            if (isNaN(codepoint)) {
+                return char;
+            }
+            char += iterator.charAt(ind);
+            if (isNewLine(codepoint)) {
+                lin++;
+                col = 0;
+            }
+            else {
+                col++;
+            }
+        }
+        return char;
+    }
+    while (value = next()) {
+        if (ind >= iterator.length) {
+            if (buffer.length > 0) {
+                yield pushToken(buffer);
+                buffer = '';
+            }
+            break;
+        }
+        if (isWhiteSpace(value.charCodeAt(0))) {
+            if (buffer.length > 0) {
+                yield pushToken(buffer);
+                buffer = '';
+            }
+            while (value = next()) {
+                if (ind >= iterator.length) {
+                    break;
+                }
+                if (!isWhiteSpace(value.charCodeAt(0))) {
+                    break;
+                }
+            }
+            yield pushToken('', 'Whitespace');
+            buffer = '';
+            if (ind >= iterator.length) {
+                break;
+            }
+        }
+        switch (value) {
+            case '/':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                    if (peek() != '*') {
+                        yield pushToken(value);
+                        break;
+                    }
+                }
+                buffer += value;
+                if (peek() == '*') {
+                    buffer += '*';
+                    // i++;
+                    next();
+                    while (value = next()) {
+                        if (ind >= iterator.length) {
+                            yield pushToken(buffer, 'Bad-comment');
+                            break;
+                        }
+                        if (value == '\\') {
+                            buffer += value;
+                            value = next();
+                            if (ind >= iterator.length) {
+                                yield pushToken(buffer, 'Bad-comment');
+                                break;
+                            }
+                            buffer += value;
+                            continue;
+                        }
+                        if (value == '*') {
+                            buffer += value;
+                            value = next();
+                            if (ind >= iterator.length) {
+                                yield pushToken(buffer, 'Bad-comment');
+                                break;
+                            }
+                            buffer += value;
+                            if (value == '/') {
+                                yield pushToken(buffer, 'Comment');
+                                buffer = '';
+                                break;
+                            }
+                        }
+                        else {
+                            buffer += value;
+                        }
+                    }
+                }
+                break;
+            case '<':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                buffer += value;
+                value = next();
+                if (ind >= iterator.length) {
+                    break;
+                }
+                if (peek(3) == '!--') {
+                    while (value = next()) {
+                        if (ind >= iterator.length) {
+                            break;
+                        }
+                        buffer += value;
+                        if (value == '>' && prev(2) == '--') {
+                            yield pushToken(buffer, 'CDOCOMM');
+                            buffer = '';
+                            break;
+                        }
+                    }
+                }
+                if (ind >= iterator.length) {
+                    yield pushToken(buffer, 'BADCDO');
+                    buffer = '';
+                }
+                break;
+            case '\\':
+                value = next();
+                // EOF
+                if (ind + 1 >= iterator.length) {
+                    // end of stream ignore \\
+                    yield pushToken(buffer);
+                    buffer = '';
+                    break;
+                }
+                buffer += value;
+                break;
+            case '"':
+            case "'":
+                yield* consumeString(value);
+                break;
+            case '~':
+            case '|':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                buffer += value;
+                value = next();
+                if (ind >= iterator.length) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                    break;
+                }
+                if (value == '=') {
+                    buffer += value;
+                    yield pushToken(buffer, buffer[0] == '~' ? 'Includes' : 'Dash-matches');
+                    buffer = '';
+                    break;
+                }
+                yield pushToken(buffer);
+                while (isWhiteSpace(value.charCodeAt(0))) {
+                    value = next();
+                }
+                buffer = value;
+                break;
+            case '>':
+                if (buffer !== '') {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                yield pushToken('', 'Gt');
+                consumeWhiteSpace();
+                break;
+            case '.':
+                const codepoint = peek().charCodeAt(0);
+                if (!isDigit(codepoint) && buffer !== '') {
+                    yield pushToken(buffer);
+                    buffer = value;
+                    break;
+                }
+                buffer += value;
+                break;
+            case '+':
+            case ':':
+            case ',':
+            case '=':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                if (value == ':' && ':' == peek()) {
+                    buffer += value + next();
+                    break;
+                }
+                yield pushToken(value);
+                buffer = '';
+                if (value == '+' && isWhiteSpace(peek().charCodeAt(0))) {
+                    yield pushToken(next());
+                }
+                while (isWhiteSpace(peek().charCodeAt(0))) {
+                    next();
+                }
+                break;
+            case ')':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                yield pushToken('', 'End-parens');
+                break;
+            case '(':
+                if (buffer.length == 0) {
+                    yield pushToken('', 'Start-parens');
+                    break;
+                }
+                buffer += value;
+                // @ts-ignore
+                if (buffer == 'url(') {
+                    yield pushToken(buffer);
+                    buffer = '';
+                    // consume either string or url token
+                    let whitespace = '';
+                    value = peek();
+                    while (isWhiteSpace(value.charCodeAt(0))) {
+                        whitespace += value;
+                    }
+                    if (whitespace.length > 0) {
+                        next(whitespace.length);
+                    }
+                    value = peek();
+                    if (value == '"' || value == "'") {
+                        yield* consumeString(next());
+                        break;
+                    }
+                    else {
+                        buffer = '';
+                        do {
+                            let cp = value.charCodeAt(0);
+                            // EOF -
+                            if (cp == null) {
+                                yield pushToken('', 'Bad-url-token');
+                                break;
+                            }
+                            // ')'
+                            if (cp == 0x29 || cp == null) {
+                                if (buffer.length == 0) {
+                                    yield pushToken(buffer, 'Bad-url-token');
+                                }
+                                else {
+                                    yield pushToken(buffer, 'Url-token');
+                                }
+                                if (cp != null) {
+                                    yield pushToken(next());
+                                }
+                                break;
+                            }
+                            if (isWhiteSpace(cp)) {
+                                whitespace = next();
+                                while (true) {
+                                    value = peek();
+                                    cp = value.charCodeAt(0);
+                                    if (isWhiteSpace(cp)) {
+                                        whitespace += value;
+                                        continue;
+                                    }
+                                    break;
+                                }
+                                if (cp == null || cp == 0x29) {
+                                    continue;
+                                }
+                                // bad url token
+                                buffer += next(whitespace.length);
+                                do {
+                                    value = peek();
+                                    cp = value.charCodeAt(0);
+                                    if (cp == null || cp == 0x29) {
+                                        break;
+                                    }
+                                    buffer += next();
+                                } while (true);
+                                yield pushToken(buffer, 'Bad-url-token');
+                                continue;
+                            }
+                            buffer += next();
+                            value = peek();
+                        } while (true);
+                        buffer = '';
+                    }
+                    break;
+                }
+                yield pushToken(buffer);
+                buffer = '';
+                break;
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case ';':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                yield pushToken(value);
+                break;
+            case '!':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                const important = peek(9);
+                if (important == 'important') {
+                    yield pushToken('', 'Important');
+                    next(9);
+                    buffer = '';
+                    break;
+                }
+                buffer = '!';
+                break;
+            default:
+                buffer += value;
+                break;
+        }
+    }
+    if (buffer.length > 0) {
+        yield pushToken(buffer);
+    }
+}
+
+export { tokenize };

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

@@ -1,13 +1,37 @@
 function eq(a, b) {
-    if ((typeof a != 'object') || typeof b != 'object') {
+    if (a == null || b == null) {
+        return a == b;
+    }
+    if (typeof a != 'object' || typeof b != 'object') {
         return a === b;
     }
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        if (a.length != b.length) {
+            return false;
+        }
+        let i = 0;
+        for (; i < a.length; i++) {
+            if (!eq(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
     const k1 = Object.keys(a);
     const k2 = Object.keys(b);
-    return k1.length == k2.length &&
-        k1.every((key) => {
-            return eq(a[key], b[key]);
-        });
+    if (k1.length != k2.length) {
+        return false;
+    }
+    let key;
+    for (key of k1) {
+        if (!eq(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
 }
 
 export { eq };

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

@@ -2,13 +2,14 @@
 // https://www.w3.org/TR/2021/CRD-css-syntax-3-20211224/#typedef-ident-token
 // '\\'
 const REVERSE_SOLIDUS = 0x5c;
+const dimensionUnits = [
+    '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'
+];
 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());
+    return 'unit' in dimension && dimensionUnits.includes(dimension.unit.toLowerCase());
 }
 function isResolution(dimension) {
     return 'unit' in dimension && ['dpi', 'dpcm', 'dppx', 'x'].includes(dimension.unit.toLowerCase());
@@ -233,6 +234,22 @@ function isHexColor(name) {
     }
     return true;
 }
+function isHexDigit(name) {
+    if (name.length || name.length > 6) {
+        return false;
+    }
+    for (let chr of name) {
+        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));
 }
@@ -249,4 +266,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { isAngle, isAtKeyword, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension };
+export { isAngle, isAtKeyword, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isHexDigit, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension };

package/dist/lib/renderer/render.js

@@ -1,8 +1,7 @@
-import { rgb2Hex, hsl2Hex, hwb2hex, cmyk2hex, NAMES_COLORS } from './utils/color.js';
+import { COLORS_NAMES, rgb2Hex, hsl2Hex, hwb2hex, cmyk2hex, NAMES_COLORS } from './utils/color.js';
 
-const indents = [];
 function render(data, opt = {}) {
-    const options = Object.assign(opt.compress ? {
+    const options = Object.assign(opt.minify ?? true ? {
         indent: '',
         newLine: '',
         removeComments: true
@@ -18,27 +17,12 @@ function render(data, opt = {}) {
                 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' &&
-        //             (<ColorToken>original[index - 1]).kin != 'hex' &&
-        //             (<ColorToken>original[index - 1]).kin != 'lit')))) {
-        //
-        //         return acc;
-        //     }
-        // }
         return acc + renderToken(curr, options);
     }
-    return { code: doRender(data, options, reducer) };
+    return { code: doRender(data, options, reducer, 0) };
 }
 // @ts-ignore
-function doRender(data, options, reducer, level = 0) {
+function doRender(data, options, reducer, level = 0, indents = []) {
     if (indents.length < level + 1) {
         indents.push(options.indent.repeat(level));
     }
@@ -52,7 +36,7 @@ function doRender(data, options, reducer, level = 0) {
             return options.removeComments ? '' : data.val;
         case 'StyleSheet':
             return data.chi.reduce((css, node) => {
-                const str = doRender(node, options, reducer, level);
+                const str = doRender(node, options, reducer, level, indents);
                 if (str === '') {
                     return css;
                 }
@@ -79,7 +63,7 @@ function doRender(data, options, reducer, level = 0) {
                     str = `@${node.nam} ${node.val};`;
                 }
                 else {
-                    str = doRender(node, options, reducer, level + 1);
+                    str = doRender(node, options, reducer, level + 1, indents);
                 }
                 if (css === '') {
                     return str;
@@ -87,8 +71,7 @@ function doRender(data, options, reducer, level = 0) {
                 if (str === '') {
                     return css;
                 }
-                if (str !== '')
-                    return `${css}${options.newLine}${indentSub}${str}`;
+                return `${css}${options.newLine}${indentSub}${str}`;
             }, '');
             if (children.endsWith(';')) {
                 children = children.slice(0, -1);
@@ -103,8 +86,11 @@ function doRender(data, options, reducer, level = 0) {
 function renderToken(token, options = {}) {
     switch (token.typ) {
         case 'Color':
-            if (options.compress || options.colorConvert) {
-                let value = token.kin == 'hex' ? token.val.toLowerCase() : '';
+            if (options.minify || options.colorConvert) {
+                if (token.kin == 'lit' && token.val.toLowerCase() == 'currentcolor') {
+                    return 'currentcolor';
+                }
+                let value = token.kin == 'hex' ? token.val.toLowerCase() : (token.kin == 'lit' ? COLORS_NAMES[token.val.toLowerCase()] : '');
                 if (token.val == 'rgb' || token.val == 'rgba') {
                     value = rgb2Hex(token);
                 }
@@ -148,7 +134,7 @@ function renderToken(token, options = {}) {
         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) => {
+            return ( /* options.minify && '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;
@@ -239,7 +225,7 @@ function renderToken(token, options = {}) {
         case 'String':
         case 'Iden':
         case 'Delim':
-            return /* options.compress && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) :  */ token.val;
+            return /* options.minify && '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)}`);
 }

package/dist/lib/transform.js

@@ -2,7 +2,7 @@ import { parse } from './parser/parse.js';
 import { render } from './renderer/render.js';
 
 async function transform(css, options = {}) {
-    options = { compress: true, removeEmpty: true, ...options };
+    options = { minify: true, removeEmpty: true, ...options };
     const startTime = performance.now();
     const parseResult = await parse(css, options);
     const renderTime = performance.now();

package/dist/node/index.js

@@ -1,4 +1,5 @@
 import { parse as parse$1 } from '../lib/parser/parse.js';
+export { parseString, urlTokenMatcher } from '../lib/parser/parse.js';
 import '../lib/renderer/utils/color.js';
 import { transform as transform$1 } from '../lib/transform.js';
 import { load } from './load.js';

package/dist/web/index.js

@@ -1,8 +1,12 @@
 import { parse as parse$1 } from '../lib/parser/parse.js';
-export { deduplicate, deduplicateRule, hasDeclaration, reduceSelector } from '../lib/parser/deduplicate.js';
+export { parseString, urlTokenMatcher } from '../lib/parser/parse.js';
+export { tokenize } from '../lib/parser/tokenize.js';
+export { isAngle, isAtKeyword, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isHexDigit, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension } from '../lib/parser/utils/syntax.js';
+export { getConfig } from '../lib/parser/utils/config.js';
 export { render, renderToken } from '../lib/renderer/render.js';
-export { walk } from '../lib/walker/walk.js';
 import { transform as transform$1 } from '../lib/transform.js';
+export { combinators, hasDeclaration, minify, minifyRule, reduceSelector } from '../lib/ast/minify.js';
+export { walk } from '../lib/ast/walk.js';
 import { load } from './load.js';
 import { resolve, dirname } from '../lib/fs/resolve.js';
 export { matchUrl } from '../lib/fs/resolve.js';