@tbela99/css-parser 1.3.3 → 1.4.0

package/dist/lib/parser/tokenize.js

@@ -138,23 +138,27 @@ function* consumeString(quoteStr, buffer, parseInfo) {
     }
 }
 function match(parseInfo, input) {
-    return parseInfo.stream.slice(parseInfo.currentPosition.ind + 1, parseInfo.currentPosition.ind + input.length + 1) == input;
+    const position = parseInfo.currentPosition.ind - parseInfo.offset;
+    return parseInfo.stream.slice(position + 1, position + input.length + 1) == input;
 }
 function peek(parseInfo, count = 1) {
     if (count == 1) {
-        return parseInfo.stream.charAt(parseInfo.currentPosition.ind + 1);
+        return parseInfo.stream.charAt(parseInfo.currentPosition.ind - parseInfo.offset + 1);
     }
-    return parseInfo.stream.slice(parseInfo.currentPosition.ind + 1, parseInfo.currentPosition.ind + count + 1);
+    const position = parseInfo.currentPosition.ind - parseInfo.offset;
+    return parseInfo.stream.slice(position + 1, position + count + 1);
 }
 function prev(parseInfo) {
-    return parseInfo.stream.charAt(parseInfo.currentPosition.ind - 1);
+    return parseInfo.offset == parseInfo.currentPosition.ind ? parseInfo.buffer.slice(-1) : parseInfo.stream.charAt(parseInfo.currentPosition.ind - parseInfo.offset - 1);
 }
 function next(parseInfo, count = 1) {
     let char = '';
     let chr = '';
-    while (count-- && (chr = parseInfo.stream.charAt(parseInfo.currentPosition.ind + 1))) {
+    let position = parseInfo.currentPosition.ind - parseInfo.offset;
+    while (count-- && (chr = parseInfo.stream.charAt(position + 1))) {
         char += chr;
-        const codepoint = parseInfo.stream.charCodeAt(++parseInfo.currentPosition.ind);
+        const codepoint = parseInfo.stream.charCodeAt(++position);
+        ++parseInfo.currentPosition.ind;
         if (isNewLine(codepoint)) {
             parseInfo.currentPosition.lin++;
             parseInfo.currentPosition.col = 0;
@@ -182,13 +186,15 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                 yield pushToken(buffer, parseInfo);
                 buffer = '';
             }
+            buffer += value;
             while (value = next(parseInfo)) {
                 charCode = value.charCodeAt(0);
                 if (!isWhiteSpace(charCode)) {
                     break;
                 }
+                buffer += value;
             }
-            yield pushToken('', parseInfo, EnumToken.WhitespaceTokenType);
+            yield pushToken(buffer, parseInfo, EnumToken.WhitespaceTokenType);
             buffer = '';
         }
         switch (charCode) {
@@ -236,8 +242,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     buffer = '';
                 }
                 if (match(parseInfo, '=')) {
-                    yield pushToken('', parseInfo, EnumToken.LteTokenType);
-                    next(parseInfo);
+                    yield pushToken(value + next(parseInfo), parseInfo, EnumToken.LteTokenType);
                     break;
                 }
                 buffer += value;
@@ -292,8 +297,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                 }
                 if (charCode == 124 /* TokenMap.PIPE */) {
                     if (match(parseInfo, '|')) {
-                        next(parseInfo);
-                        yield pushToken('', parseInfo, EnumToken.ColumnCombinatorTokenType);
+                        yield pushToken(value + next(parseInfo), parseInfo, EnumToken.ColumnCombinatorTokenType);
                     }
                     else if (match(parseInfo, '=')) {
                         buffer += next(parseInfo);
@@ -347,11 +351,10 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     buffer = '';
                 }
                 if (match(parseInfo, '=')) {
-                    yield pushToken('', parseInfo, EnumToken.GteTokenType);
-                    next(parseInfo);
+                    yield pushToken(value + next(parseInfo), parseInfo, EnumToken.GteTokenType);
                 }
                 else {
-                    yield pushToken('', parseInfo, EnumToken.GtTokenType);
+                    yield pushToken(value, parseInfo, EnumToken.GtTokenType);
                 }
                 consumeWhiteSpace(parseInfo);
                 break;
@@ -402,7 +405,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     yield pushToken(buffer, parseInfo);
                     buffer = '';
                 }
-                yield pushToken('', parseInfo, EnumToken.EndParensTokenType);
+                yield pushToken(value, parseInfo, EnumToken.EndParensTokenType);
                 break;
             case 40 /* TokenMap.OPEN_PAREN */:
                 if (buffer.length == 0) {
@@ -468,7 +471,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                                 // ')'
                                 if (charCode == 0x29) {
                                     yield pushToken(buffer, parseInfo, hasNewLine ? EnumToken.BadStringTokenType : EnumToken.StringTokenType);
-                                    yield pushToken('', parseInfo, EnumToken.EndParensTokenType);
+                                    yield pushToken(value, parseInfo, EnumToken.EndParensTokenType);
                                     buffer = '';
                                     break;
                                 }
@@ -492,7 +495,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                             charCode = value.charCodeAt(0);
                             if (charCode == 0x29) { // ')'
                                 yield pushToken(buffer, parseInfo, EnumToken.UrlTokenTokenType);
-                                yield pushToken('', parseInfo, EnumToken.EndParensTokenType);
+                                yield pushToken(value, parseInfo, EnumToken.EndParensTokenType);
                                 buffer = '';
                                 break;
                             }
@@ -526,8 +529,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     buffer = '';
                 }
                 if (match(parseInfo, 'important')) {
-                    yield pushToken('', parseInfo, EnumToken.ImportantTokenType);
-                    next(parseInfo, 9);
+                    yield pushToken(value + next(parseInfo, 9), parseInfo, EnumToken.ImportantTokenType);
                     buffer = '';
                     break;
                 }
@@ -572,6 +574,7 @@ async function* tokenizeStream(input) {
     const parseInfo = {
         stream: '',
         buffer: '',
+        offset: 0,
         position: { ind: 0, lin: 1, col: 1 },
         currentPosition: { ind: -1, lin: 1, col: 0 }
     };
@@ -579,7 +582,17 @@ async function* tokenizeStream(input) {
     const reader = input.getReader();
     while (true) {
         const { done, value } = await reader.read();
-        parseInfo.stream += ArrayBuffer.isView(value) ? decoder.decode(value, { stream: true }) : value;
+        const stream = ArrayBuffer.isView(value) ? decoder.decode(value, { stream: true }) : value;
+        if (!done) {
+            if (parseInfo.stream.length > 2) {
+                parseInfo.stream = parseInfo.stream.slice(-2) + stream;
+                parseInfo.offset = parseInfo.currentPosition.ind - 1;
+            }
+            else {
+                parseInfo.stream = stream;
+                parseInfo.offset = Math.max(0, parseInfo.currentPosition.ind);
+            }
+        }
         yield* tokenize(parseInfo, done);
         if (done) {
             break;

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

@@ -20,6 +20,60 @@ function parseDeclarationNode(node, errors, location) {
         });
         return null;
     }
+    if ('composes' == node.nam.toLowerCase()) {
+        let left = [];
+        let right = [];
+        let current = 0;
+        let hasFrom = 0;
+        for (; current < node.val.length; current++) {
+            if (EnumToken.WhitespaceTokenType == node.val[current].typ || EnumToken.CommentTokenType == node.val[current].typ) {
+                if (!hasFrom) {
+                    left.push(node.val[current]);
+                }
+                else {
+                    right.push(node.val[current]);
+                }
+                continue;
+            }
+            if (EnumToken.IdenTokenType == node.val[current].typ || EnumToken.DashedIdenTokenType == node.val[current].typ || EnumToken.StringTokenType == node.val[current].typ) {
+                if (EnumToken.IdenTokenType == node.val[current].typ) {
+                    if ('from' == node.val[current].val) {
+                        if (hasFrom) {
+                            return null;
+                        }
+                        hasFrom++;
+                        continue;
+                    }
+                }
+                if (hasFrom) {
+                    right.push(node.val[current]);
+                }
+                else {
+                    left.push(node.val[current]);
+                }
+                continue;
+            }
+            break;
+        }
+        if (hasFrom <= 1 && current > 0) {
+            if (hasFrom == 0) {
+                node.val.splice(0, left.length, {
+                    typ: EnumToken.ComposesSelectorNodeType,
+                    l: left,
+                    r: null
+                });
+            }
+            else {
+                node.val.splice(0, current, {
+                    typ: EnumToken.ComposesSelectorNodeType,
+                    l: left,
+                    r: right.reduce((a, b) => {
+                        return a == null ? b : b.typ == EnumToken.WhitespaceTokenType || b.typ == EnumToken.CommentTokenType ? a : b;
+                    }, null)
+                });
+            }
+        }
+    }
     for (const { value: val, parent } of walkValues(node.val, node)) {
         if (val.typ == EnumToken.AttrTokenType && val.chi.every((t) => [EnumToken.IdenTokenType, EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ))) {
             // @ts-ignore

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

@@ -0,0 +1,86 @@
+// Alphabet: a-z, A-Z, 0-9, _, -
+const LOWER = "abcdefghijklmnopqrstuvwxyz";
+const DIGITS = "0123456789";
+const FULL_ALPHABET = (LOWER + DIGITS).split(""); // 64 chars
+const FIRST_ALPHABET = (LOWER).split(""); // 54 chars (no digits)
+/**
+ * supported hash algorithms
+ */
+const hashAlgorithms = ['hex', 'base64', 'base64url', 'sha1', 'sha256', 'sha384', 'sha512'];
+// simple deterministic hash → number
+function hashCode(str) {
+    let hash = 0;
+    let l = str.length;
+    let i = 0;
+    while (i < l) {
+        hash = (hash * 31 + str.charCodeAt(i++)) >>> 0;
+    }
+    return hash;
+}
+/**
+ * generate a hash id
+ * @param input
+ * @param length
+ */
+function hashId(input, length = 6) {
+    let n = hashCode(input);
+    const chars = [];
+    // First character: must not be a digit
+    chars.push(FIRST_ALPHABET[n % FIRST_ALPHABET.length]);
+    // Remaining characters
+    for (let i = 1; i < length; i++) {
+        n = (n + chars.length + i) % FULL_ALPHABET.length;
+        chars.push(FULL_ALPHABET[n]);
+    }
+    return chars.join("");
+}
+/**
+ * convert input to hex
+ * @param input
+ */
+function toHex(input) {
+    let result = '';
+    if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+        for (const byte of Array.from(new Uint8Array(input))) {
+            result += byte.toString(16).padStart(2, '0');
+        }
+    }
+    else {
+        for (const char of String(input)) {
+            result += char.charCodeAt(0).toString(16).padStart(2, '0');
+        }
+    }
+    return result;
+}
+/**
+ * generate a hash
+ * @param input
+ * @param length
+ * @param algo
+ */
+async function hash(input, length = 6, algo) {
+    let result;
+    if (algo != null) {
+        switch (algo) {
+            case 'hex':
+                return toHex(input).slice(0, length);
+            case 'base64':
+            case 'base64url':
+                result = btoa(input);
+                if (algo == 'base64url') {
+                    result = result.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+                }
+                return result.slice(0, length);
+            case 'sha1':
+            case 'sha256':
+            case 'sha384':
+            case 'sha512':
+                return toHex(await crypto.subtle.digest(algo.replace('sha', 'SHA-'), new TextEncoder().encode(input))).slice(0, length);
+            default:
+                throw new Error(`Unsupported hash algorithm: ${algo}`);
+        }
+    }
+    return hashId(input, length);
+}
+
+export { hash, hashAlgorithms, hashId };

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

@@ -0,0 +1,8 @@
+function dasherize(value) {
+    return value.replace(/([A-Z])/g, (all, one) => `-${one.toLowerCase()}`);
+}
+function camelize(value) {
+    return value.replace(/-([a-z])/g, (all, one) => one.toUpperCase());
+}
+
+export { camelize, dasherize };

package/dist/lib/renderer/render.js

@@ -29,9 +29,10 @@ function update(position, str) {
  * render ast
  * @param data
  * @param options
+ * @param mapping
  * @private
  */
-function doRender(data, options = {}) {
+function doRender(data, options = {}, mapping) {
     const minify = options.minify ?? true;
     const beautify = options.beautify ?? !minify;
     options = {
@@ -68,12 +69,23 @@ function doRender(data, options = {}) {
     const errors = [];
     const sourcemap = options.sourcemap ? new SourceMap : null;
     const cache = Object.create(null);
+    const position = {
+        ind: 0,
+        lin: 1,
+        col: 1
+    };
+    let code = '';
+    if (mapping != null) {
+        if (mapping.importMapping != null) {
+            for (const [key, value] of Object.entries(mapping.importMapping)) {
+                code += `:import("${key}")${options.indent}{${options.newLine}${Object.entries(value).reduce((acc, [k, v]) => acc + (acc.length > 0 ? options.newLine : '') + `${options.indent}${v}:${options.indent}${k};`, '')}${options.newLine}}${options.newLine}`;
+            }
+        }
+        code += `:export${options.indent}{${options.newLine}${Object.entries(mapping.mapping).reduce((acc, [k, v]) => acc + (acc.length > 0 ? options.newLine : '') + `${options.indent}${k}:${options.indent}${v};`, '')}${options.newLine}}${options.newLine}`;
+        update(position, code);
+    }
     const result = {
-        code: renderAstNode(options.expandNestingRules ? expand(data) : data, options, sourcemap, {
-            ind: 0,
-            lin: 1,
-            col: 1
-        }, errors, function reducer(acc, curr) {
+        code: code + renderAstNode(options.expandNestingRules && [EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType, EnumToken.RuleNodeType].includes(data.typ) && 'chi' in data ? expand(data) : data, options, sourcemap, position, errors, function reducer(acc, curr) {
             if (curr.typ == EnumToken.CommentTokenType && options.removeComments) {
                 if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
                     return acc;
@@ -209,7 +221,7 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
                     str = `${node.nam}:${options.indent}${(options.minify ? filterValues(node.val) : node.val).reduce(reducer, '').trimEnd()};`;
                 }
                 else if (node.typ == EnumToken.AtRuleNodeType && !('chi' in node)) {
-                    str = `${data.val === '' ? '' : options.indent || ' '}${data.val};`;
+                    str = `${node.val === '' ? '' : options.indent || ' '}${node.val};`;
                 }
                 else {
                     str = renderAstNode(node, options, sourcemap, { ...position }, errors, reducer, cache, level + 1, indents);
@@ -232,6 +244,11 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
                 return `@${data.nam}${data.val === '' ? '' : options.indent || ' '}${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 + `}`;
+        case EnumToken.CssVariableTokenType:
+        case EnumToken.CssVariableImportTokenType:
+            return `@value ${data.nam}:${options.indent}${filterValues((options.minify ? data.val : data.val)).reduce(reducer, '').trim()};`;
+        case EnumToken.CssVariableDeclarationMapTokenType:
+            return `@value ${filterValues(data.vars).reduce((acc, curr) => acc + renderToken(curr), '').trim()} from ${filterValues(data.from).reduce((acc, curr) => acc + renderToken(curr), '').trim()};`;
         case EnumToken.InvalidDeclarationNodeType:
         case EnumToken.InvalidRuleTokenType:
         case EnumToken.InvalidAtRuleTokenType:
@@ -386,6 +403,8 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
         case EnumToken.NameSpaceAttributeTokenType:
             return (token.l == null ? '' : renderToken(token.l, options, cache, reducer, errors)) + '|' +
                 renderToken(token.r, options, cache, reducer, errors);
+        case EnumToken.ComposesSelectorNodeType:
+            return token.l.reduce((acc, curr) => acc + renderToken(curr, options, cache), '') + (token.r == null ? '' : ' from ' + renderToken(token.r, options, cache, reducer, errors));
         case EnumToken.BlockStartTokenType:
             return '{';
         case EnumToken.BlockEndTokenType:

package/dist/lib/syntax/color/relativecolor.js

@@ -77,10 +77,7 @@ function computeComponentValue(expr, converted, values) {
             // normalize hue
             for (const k of walkValues([object.h])) {
                 if (k.value.typ == EnumToken.AngleTokenType && k.value.unit == 'deg') {
-                    // @ts-ignore
                     k.value.typ = EnumToken.NumberTokenType;
-                    // @ts-ignore
-                    delete k.value.unit;
                 }
             }
         }

package/dist/lib/syntax/syntax.js

@@ -528,7 +528,7 @@ function isColor(token) {
     }
     if (token.typ == EnumToken.IdenTokenType) {
         // named color
-        return token.val.toLowerCase() in COLORS_NAMES;
+        return token.val.toLowerCase() in COLORS_NAMES || 'currentcolor' === token.val.toLowerCase() || 'transparent' === token.val.toLowerCase();
     }
     let isLegacySyntax = false;
     if (token.typ == EnumToken.FunctionTokenType) {
@@ -581,8 +581,13 @@ function isColor(token) {
                             return false;
                         }
                     }
-                    if (children[i].typ == EnumToken.FunctionTokenType && !mathFuncs.includes(children[i].val)) {
-                        return false;
+                    if (children[i].typ == EnumToken.FunctionTokenType) {
+                        if ('var' == children[i].val.toLowerCase()) {
+                            continue;
+                        }
+                        if (!mathFuncs.includes(children[i].val)) {
+                            return false;
+                        }
                     }
                 }
                 if (children.length == 4 || (isRelative && children.length == 6)) {
@@ -869,23 +874,29 @@ function isNumber(name) {
     }
     return true;
 }
-function isDimension(name) {
-    let index = name.length;
-    while (index--) {
-        if (isLetter(name.charCodeAt(index))) {
-            continue;
-        }
-        index++;
-        break;
-    }
-    const number = name.slice(0, index);
-    return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
-}
+// export function isDimension(name: string) {
+//
+//     let index: number = name.length;
+//
+//     while (index--) {
+//
+//         if (isLetter(<number>name.charCodeAt(index))) {
+//
+//             continue
+//         }
+//
+//         index++;
+//         break;
+//     }
+//
+//     const number: string = name.slice(0, index);
+//     return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
+// }
 function isPercentage(name) {
     return name.endsWith('%') && isNumber(name.slice(0, -1));
 }
-function isFlex(name) {
-    return name.endsWith('fr') && isNumber(name.slice(0, -2));
+function isFlex(dimension) {
+    return 'unit' in dimension && 'fr' == dimension.unit.toLowerCase();
 }
 function parseDimension(name) {
     let index = name.length;
@@ -901,6 +912,9 @@ function parseDimension(name) {
         val: +name.slice(0, index),
         unit: name.slice(index)
     };
+    if (index < 0 || Number.isNaN(dimension.val)) {
+        return null;
+    }
     if (isAngle(dimension)) {
         // @ts-ignore
         dimension.typ = EnumToken.AngleTokenType;
@@ -924,6 +938,10 @@ function parseDimension(name) {
         // @ts-ignore
         dimension.typ = EnumToken.FrequencyTokenType;
     }
+    else if (isFlex(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.FlexTokenType;
+    }
     return dimension;
 }
 function isHexColor(name) {
@@ -958,4 +976,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentColor, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPercentageToken, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseColor, parseDimension, pseudoAliasMap, pseudoElements, transformFunctions, webkitExtensions, wildCardFuncs };
+export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentColor, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPercentageToken, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseColor, parseDimension, pseudoAliasMap, pseudoElements, transformFunctions, webkitExtensions, wildCardFuncs };

package/dist/lib/validation/at-rules/container.js

@@ -11,6 +11,17 @@ import { splitTokenList } from '../utils/list.js';
 
 const validateContainerScrollStateFeature = validateContainerSizeFeature;
 function validateAtRuleContainer(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/at-rules/counter-style.js

@@ -8,6 +8,17 @@ import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function validateAtRuleCounterStyle(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/at-rules/font-feature-values.js

@@ -12,6 +12,17 @@ import '../syntax.js';
 import '../config.js';
 
 function validateAtRuleFontFeatureValues(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {

package/dist/lib/validation/at-rules/keyframes.js

@@ -9,6 +9,17 @@ import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 
 function validateAtRuleKeyframes(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {

package/dist/lib/validation/at-rules/layer.js

@@ -12,6 +12,17 @@ import '../syntax.js';
 import '../config.js';
 
 function validateAtRuleLayer(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/at-rules/media.js

@@ -10,6 +10,17 @@ import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';
 
 function validateAtRuleMedia(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/at-rules/page-margin-box.js

@@ -8,6 +8,17 @@ import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function validateAtRulePageMarginBox(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     if (Array.isArray(atRule.tokens) && atRule.tokens.length > 0) {
         // @ts-ignore
         return {

package/dist/lib/validation/at-rules/page.js

@@ -9,6 +9,17 @@ import '../../renderer/sourcemap/lib/encode.js';
 import { splitTokenList } from '../utils/list.js';
 
 function validateAtRulePage(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/at-rules/supports.js

@@ -23,6 +23,17 @@ function validateAtRuleSupports(atRule, options, root) {
             tokens: []
         };
     }
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     const result = validateAtRuleSupportsConditions(atRule, atRule.tokens);
     if (result) {
         if (result.node == null) {