@tbela99/css-parser 0.8.0 → 0.9.0

package/dist/lib/syntax/syntax.js

@@ -25,6 +25,341 @@ const mediaTypes = ['all', 'print', 'screen',
     'aural', 'braille', 'embossed', 'handheld', 'projection', 'tty', 'tv', 'speech'];
 // https://www.w3.org/TR/css-values-4/#math-function
 const mathFuncs = ['calc', 'clamp', 'min', 'max', 'round', 'mod', 'rem', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'pow', 'sqrt', 'hypot', 'log', 'exp', 'abs', 'sign'];
+const webkitPseudoAliasMap = {
+    '-webkit-autofill': 'autofill',
+    '-webkit-any': 'is',
+    '-moz-any': 'is',
+    '-webkit-border-after': 'border-block-end',
+    '-webkit-border-after-color': 'border-block-end-color',
+    '-webkit-border-after-style': 'border-block-end-style',
+    '-webkit-border-after-width': 'border-block-end-width',
+    '-webkit-border-before': 'border-block-start',
+    '-webkit-border-before-color': 'border-block-start-color',
+    '-webkit-border-before-style': 'border-block-start-style',
+    '-webkit-border-before-width': 'border-block-start-width',
+    '-webkit-border-end': 'border-inline-end',
+    '-webkit-border-end-color': 'border-inline-end-color',
+    '-webkit-border-end-style': 'border-inline-end-style',
+    '-webkit-border-end-width': 'border-inline-end-width',
+    '-webkit-border-start': 'border-inline-start',
+    '-webkit-border-start-color': 'border-inline-start-color',
+    '-webkit-border-start-style': 'border-inline-start-style',
+    '-webkit-border-start-width': 'border-inline-start-width',
+    '-webkit-box-align': 'align-items',
+    '-webkit-box-direction': 'flex-direction',
+    '-webkit-box-flex': 'flex-grow',
+    '-webkit-box-lines': 'flex-flow',
+    '-webkit-box-ordinal-group': 'order',
+    '-webkit-box-orient': 'flex-direction',
+    '-webkit-box-pack': 'justify-content',
+    '-webkit-column-break-after': 'break-after',
+    '-webkit-column-break-before': 'break-before',
+    '-webkit-column-break-inside': 'break-inside',
+    '-webkit-font-feature-settings': 'font-feature-settings',
+    '-webkit-hyphenate-character': 'hyphenate-character',
+    '-webkit-initial-letter': 'initial-letter',
+    '-webkit-margin-end': 'margin-block-end',
+    '-webkit-margin-start': 'margin-block-start',
+    '-webkit-padding-after': 'padding-block-end',
+    '-webkit-padding-before': 'padding-block-start',
+    '-webkit-padding-end': 'padding-inline-end',
+    '-webkit-padding-start': 'padding-inline-start',
+    '-webkit-min-device-pixel-ratio': 'min-resolution',
+    '-webkit-max-device-pixel-ratio': 'max-resolution'
+};
+// https://developer.mozilla.org/en-US/docs/Web/CSS/WebKit_Extensions
+// https://developer.mozilla.org/en-US/docs/Web/CSS/::-webkit-scrollbar
+const webkitExtensions = new Set([
+    '-webkit-app-region',
+    '-webkit-border-horizontal-spacing',
+    '-webkit-border-vertical-spacing',
+    '-webkit-box-reflect',
+    '-webkit-column-axis',
+    '-webkit-column-progression',
+    '-webkit-cursor-visibility',
+    '-webkit-font-smoothing',
+    '-webkit-hyphenate-limit-after',
+    '-webkit-hyphenate-limit-before',
+    '-webkit-hyphenate-limit-lines',
+    '-webkit-line-align',
+    '-webkit-line-box-contain',
+    '-webkit-line-clamp',
+    '-webkit-line-grid',
+    '-webkit-line-snap',
+    '-webkit-locale',
+    '-webkit-logical-height',
+    '-webkit-logical-width',
+    '-webkit-margin-after',
+    '-webkit-margin-before',
+    '-webkit-mask-box-image-outset',
+    '-webkit-mask-box-image-repeat',
+    '-webkit-mask-box-image-slice',
+    '-webkit-mask-box-image-source',
+    '-webkit-mask-box-image-width',
+    '-webkit-mask-box-image',
+    '-webkit-mask-composite',
+    '-webkit-mask-position-x',
+    '-webkit-mask-position-y',
+    '-webkit-mask-repeat-x',
+    '-webkit-mask-repeat-y',
+    '-webkit-mask-source-type',
+    '-webkit-max-logical-height',
+    '-webkit-max-logical-width',
+    '-webkit-min-logical-height',
+    '-webkit-min-logical-width',
+    '-webkit-nbsp-mode',
+    '-webkit-perspective-origin-x',
+    '-webkit-perspective-origin-y',
+    '-webkit-rtl-ordering',
+    '-webkit-tap-highlight-color',
+    '-webkit-text-decoration-skip',
+    '-webkit-text-decorations-in-effect',
+    '-webkit-text-fill-color',
+    '-webkit-text-security',
+    '-webkit-text-stroke-color',
+    '-webkit-text-stroke-width',
+    '-webkit-text-stroke',
+    '-webkit-text-zoom',
+    '-webkit-touch-callout',
+    '-webkit-transform-origin-x',
+    '-webkit-transform-origin-y',
+    '-webkit-transform-origin-z',
+    '-webkit-user-drag',
+    '-webkit-user-modify',
+    '-webkit-border-after',
+    '-webkit-border-after-color',
+    '-webkit-border-after-style',
+    '-webkit-border-after-width',
+    '-webkit-border-before',
+    '-webkit-border-before-color',
+    '-webkit-border-before-style',
+    '-webkit-border-before-width',
+    '-webkit-border-end',
+    '-webkit-border-end-color',
+    '-webkit-border-end-style',
+    '-webkit-border-end-width',
+    '-webkit-border-start',
+    '-webkit-border-start-color',
+    '-webkit-border-start-style',
+    '-webkit-border-start-width',
+    '-webkit-box-align',
+    '-webkit-box-direction',
+    '-webkit-box-flex-group',
+    '-webkit-box-flex',
+    '-webkit-box-lines',
+    '-webkit-box-ordinal-group',
+    '-webkit-box-orient',
+    '-webkit-box-pack',
+    '-webkit-column-break-after',
+    '-webkit-column-break-before',
+    '-webkit-column-break-inside',
+    '-webkit-font-feature-settings',
+    '-webkit-hyphenate-character',
+    '-webkit-initial-letter',
+    '-webkit-margin-end',
+    '-webkit-margin-start',
+    '-webkit-padding-after',
+    '-webkit-padding-before',
+    '-webkit-padding-end',
+    '-webkit-padding-start',
+    '-webkit-fill-available',
+    ':-webkit-animating-full-screen-transition',
+    ':-webkit-any',
+    ':-webkit-any-link',
+    ':-webkit-autofill',
+    ':-webkit-autofill-strong-password',
+    ':-webkit-drag',
+    ':-webkit-full-page-media',
+    ':-webkit-full-screen*',
+    ':-webkit-full-screen-ancestor',
+    ':-webkit-full-screen-document',
+    ':-webkit-full-screen-controls-hidden',
+    '::-webkit-file-upload-button*',
+    '::-webkit-inner-spin-button',
+    '::-webkit-input-placeholder',
+    '::-webkit-meter-bar',
+    '::-webkit-meter-even-less-good-value',
+    '::-webkit-meter-inner-element',
+    '::-webkit-meter-optimum-value',
+    '::-webkit-meter-suboptimum-value',
+    '::-webkit-progress-bar',
+    '::-webkit-progress-inner-element',
+    '::-webkit-progress-value',
+    '::-webkit-search-cancel-button',
+    '::-webkit-search-results-button',
+    '::-webkit-slider-runnable-track',
+    '::-webkit-slider-thumb',
+    '-webkit-animation',
+    '-webkit-device-pixel-ratio',
+    '-webkit-transform-2d',
+    '-webkit-transform-3d',
+    '-webkit-transition',
+    '::-webkit-scrollbar',
+    '::-webkit-scrollbar-button',
+    '::-webkit-scrollbar',
+    '::-webkit-scrollbar-thumb',
+    '::-webkit-scrollbar-track',
+    '::-webkit-scrollbar-track-piece',
+    '::-webkit-scrollbar:vertical',
+    '::-webkit-scrollbar-corner ',
+    '::-webkit-resizer',
+    ':vertical',
+    ':horizontal',
+]);
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Mozilla_Extensions
+const mozExtensions = new Set([
+    '-moz-box-align',
+    '-moz-box-direction',
+    '-moz-box-flex',
+    '-moz-box-ordinal-group',
+    '-moz-box-orient',
+    '-moz-box-pack',
+    '-moz-float-edge',
+    '-moz-force-broken-image-icon',
+    '-moz-image-region',
+    '-moz-orient',
+    '-moz-osx-font-smoothing',
+    '-moz-user-focus',
+    '-moz-user-input',
+    '-moz-user-modify',
+    '-moz-animation',
+    '-moz-animation-delay',
+    '-moz-animation-direction',
+    '-moz-animation-duration',
+    '-moz-animation-fill-mode',
+    '-moz-animation-iteration-count',
+    '-moz-animation-name',
+    '-moz-animation-play-state',
+    '-moz-animation-timing-function',
+    '-moz-appearance',
+    '-moz-backface-visibility',
+    '-moz-background-clip',
+    '-moz-background-origin',
+    '-moz-background-inline-policy',
+    '-moz-background-size',
+    '-moz-border-end',
+    '-moz-border-end-color',
+    '-moz-border-end-style',
+    '-moz-border-end-width',
+    '-moz-border-image',
+    '-moz-border-start',
+    '-moz-border-start-color',
+    '-moz-border-start-style',
+    '-moz-border-start-width',
+    '-moz-box-sizing',
+    'clip-path',
+    '-moz-column-count',
+    '-moz-column-fill',
+    '-moz-column-gap',
+    '-moz-column-width',
+    '-moz-column-rule',
+    '-moz-column-rule-width',
+    '-moz-column-rule-style',
+    '-moz-column-rule-color',
+    'filter',
+    '-moz-font-feature-settings',
+    '-moz-font-language-override',
+    '-moz-hyphens',
+    '-moz-margin-end',
+    '-moz-margin-start',
+    'mask',
+    '-moz-opacity',
+    '-moz-outline',
+    '-moz-outline-color',
+    '-moz-outline-offset',
+    '-moz-outline-style',
+    '-moz-outline-width',
+    '-moz-padding-end',
+    '-moz-padding-start',
+    '-moz-perspective',
+    '-moz-perspective-origin',
+    'pointer-events',
+    '-moz-tab-size',
+    '-moz-text-align-last',
+    '-moz-text-decoration-color',
+    '-moz-text-decoration-line',
+    '-moz-text-decoration-style',
+    '-moz-text-size-adjust',
+    '-moz-transform',
+    '-moz-transform-origin',
+    '-moz-transform-style',
+    '-moz-transition',
+    '-moz-transition-delay',
+    '-moz-transition-duration',
+    '-moz-transition-property',
+    '-moz-transition-timing-function',
+    '-moz-user-select',
+    '-moz-initial',
+    '-moz-appearance',
+    '-moz-linear-gradient',
+    '-moz-radial-gradient',
+    '-moz-element',
+    '-moz-image-rect',
+    '::-moz-anonymous-block',
+    '::-moz-anonymous-positioned-block',
+    ':-moz-any',
+    ':-moz-any-link',
+    ':-moz-broken',
+    '::-moz-canvas',
+    '::-moz-color-swatch',
+    '::-moz-cell-content',
+    ':-moz-drag-over',
+    ':-moz-first-node',
+    '::-moz-focus-inner',
+    '::-moz-focus-outer',
+    ':-moz-full-screen',
+    ':-moz-full-screen-ancestor',
+    ':-moz-handler-blocked',
+    ':-moz-handler-crashed',
+    ':-moz-handler-disabled',
+    '::-moz-inline-table',
+    ':-moz-last-node',
+    '::-moz-list-bullet',
+    '::-moz-list-number',
+    ':-moz-loading',
+    ':-moz-locale-dir',
+    ':-moz-locale-dir',
+    ':-moz-lwtheme',
+    ':-moz-lwtheme-brighttext',
+    ':-moz-lwtheme-darktext',
+    '::-moz-meter-bar',
+    ':-moz-native-anonymous',
+    ':-moz-only-whitespace',
+    '::-moz-pagebreak',
+    '::-moz-pagecontent',
+    ':-moz-placeholder',
+    '::-moz-placeholder',
+    '::-moz-progress-bar',
+    '::-moz-range-progress',
+    '::-moz-range-thumb',
+    '::-moz-range-track',
+    ':-moz-read-only',
+    ':-moz-read-write',
+    '::-moz-scrolled-canvas',
+    '::-moz-scrolled-content',
+    '::-moz-selection',
+    ':-moz-submit-invalid',
+    ':-moz-suppressed',
+    '::-moz-svg-foreign-content',
+    '::-moz-table',
+    '::-moz-table-cell',
+    '::-moz-table-column',
+    '::-moz-table-column-group',
+    '::-moz-table-outer',
+    '::-moz-table-row',
+    '::-moz-table-row-group',
+    ':-moz-ui-invalid',
+    ':-moz-ui-valid',
+    ':-moz-user-disabled',
+    '::-moz-viewport',
+    '::-moz-viewport-scroll',
+    ':-moz-window-inactive',
+    '-moz-device-pixel-ratio',
+    '-moz-os-version',
+    '-moz-touch-enabled',
+    '-moz-windows-glass',
+    '-moz-alt-content'
+]);
 function isLength(dimension) {
     return 'unit' in dimension && dimensionUnits.has(dimension.unit.toLowerCase());
 }
@@ -476,4 +811,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, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, parseDimension };
+export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseDimension, webkitExtensions, webkitPseudoAliasMap };

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

@@ -0,0 +1,353 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
+
+const validateContainerScrollStateFeature = validateContainerSizeFeature;
+function validateAtRuleContainer(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports query list',
+            tokens: []
+        };
+    }
+    const result = validateAtRuleContainerQueryList(atRule.tokens, atRule);
+    if (result.valid == ValidationLevel.Drop) {
+        return result;
+    }
+    if (!('chi' in atRule)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected at-rule body',
+            tokens: []
+        };
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@' + atRule.nam,
+        error: '',
+        tokens: []
+    };
+}
+function validateAtRuleContainerQueryList(tokens, atRule) {
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected container query list',
+            tokens
+        };
+    }
+    let result = null;
+    let tokenType = null;
+    for (const queries of splitTokenList(tokens)) {
+        consumeWhitespace(queries);
+        if (queries.length == 0) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected container query list',
+                tokens
+            };
+        }
+        result = null;
+        const match = [];
+        let token = null;
+        tokenType = null;
+        while (queries.length > 0) {
+            if (queries.length == 0) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: atRule,
+                    syntax: '@' + atRule.nam,
+                    error: 'expected container query list',
+                    tokens
+                };
+            }
+            if (queries[0].typ == EnumToken.IdenTokenType) {
+                match.push(queries.shift());
+                consumeWhitespace(queries);
+            }
+            if (queries.length == 0) {
+                break;
+            }
+            token = queries[0];
+            if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+                token = token.val;
+            }
+            if (token.typ != EnumToken.ParensTokenType && (token.typ != EnumToken.FunctionTokenType || !['scroll-state', 'style'].includes(token.val))) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: queries[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expected container query-in-parens',
+                    tokens
+                };
+            }
+            if (token.typ == EnumToken.ParensTokenType) {
+                result = validateContainerSizeFeature(token.chi, atRule);
+            }
+            else if (token.val == 'scroll-state') {
+                result = validateContainerScrollStateFeature(token.chi, atRule);
+            }
+            else {
+                result = validateContainerStyleFeature(token.chi, atRule);
+            }
+            if (result.valid == ValidationLevel.Drop) {
+                return result;
+            }
+            queries.shift();
+            consumeWhitespace(queries);
+            if (queries.length == 0) {
+                break;
+            }
+            token = queries[0];
+            if (token.typ != EnumToken.MediaFeatureAndTokenType && token.typ != EnumToken.MediaFeatureOrTokenType) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: queries[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expecting and/or container query token',
+                    tokens
+                };
+            }
+            if (tokenType == null) {
+                tokenType = token.typ;
+            }
+            if (tokenType != token.typ) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: queries[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'mixing and/or not allowed at the same level',
+                    tokens
+                };
+            }
+            queries.shift();
+            consumeWhitespace(queries);
+            if (queries.length == 0) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: queries[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expected container query-in-parens',
+                    tokens
+                };
+            }
+        }
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@' + atRule.nam,
+        error: '',
+        tokens
+    };
+}
+function validateContainerStyleFeature(tokens, atRule) {
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 1) {
+        if (tokens[0].typ == EnumToken.ParensTokenType) {
+            return validateContainerStyleFeature(tokens[0].chi, atRule);
+        }
+        if ([EnumToken.DashedIdenTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ) ||
+            (tokens[0].typ == EnumToken.MediaQueryConditionTokenType && tokens[0].op.typ == EnumToken.ColonTokenType)) {
+            return {
+                valid: ValidationLevel.Valid,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: '',
+                tokens
+            };
+        }
+    }
+    return {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: atRule,
+        syntax: '@' + atRule.nam,
+        error: 'expected container query features',
+        tokens
+    };
+}
+function validateContainerSizeFeature(tokens, atRule) {
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected container query features',
+            tokens
+        };
+    }
+    if (tokens.length == 1) {
+        const token = tokens[0];
+        if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+            return validateContainerSizeFeature([token.val], atRule);
+        }
+        if (token.typ == EnumToken.ParensTokenType) {
+            return validateAtRuleContainerQueryStyleInParams(token.chi, atRule);
+        }
+        if (![EnumToken.DashedIdenTokenType, EnumToken.MediaQueryConditionTokenType].includes(tokens[0].typ)) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected container query features',
+                tokens
+            };
+        }
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: '',
+            tokens
+        };
+    }
+    return validateAtRuleContainerQueryStyleInParams(tokens, atRule);
+}
+function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected container query features',
+            tokens
+        };
+    }
+    let token = tokens[0];
+    let tokenType = null;
+    let result = null;
+    while (tokens.length > 0) {
+        token = tokens[0];
+        if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+            token = token.val;
+        }
+        if (tokens[0].typ != EnumToken.ParensTokenType) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected container query-in-parens',
+                tokens
+            };
+        }
+        const slices = tokens[0].chi.slice();
+        consumeWhitespace(slices);
+        if (slices.length == 1) {
+            if ([EnumToken.MediaFeatureNotTokenType, EnumToken.ParensTokenType].includes(slices[0].typ)) {
+                result = validateAtRuleContainerQueryStyleInParams(slices, atRule);
+                if (result.valid == ValidationLevel.Drop) {
+                    return result;
+                }
+            }
+            else if (![EnumToken.DashedIdenTokenType, EnumToken.MediaQueryConditionTokenType].includes(slices[0].typ)) {
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: atRule,
+                    syntax: '@' + atRule.nam,
+                    error: 'expected container query features',
+                    tokens
+                };
+            }
+        }
+        else {
+            result = validateAtRuleContainerQueryStyleInParams(slices, atRule);
+            if (result.valid == ValidationLevel.Drop) {
+                return result;
+            }
+        }
+        tokens.shift();
+        consumeWhitespace(tokens);
+        if (tokens.length == 0) {
+            break;
+        }
+        if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(tokens[0].typ)) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: '@' + atRule.nam,
+                error: 'expecting and/or container query token',
+                tokens
+            };
+        }
+        if (tokenType == null) {
+            tokenType = tokens[0].typ;
+        }
+        if (tokenType != tokens[0].typ) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: '@' + atRule.nam,
+                error: 'mixing and/or not allowed at the same level',
+                tokens
+            };
+        }
+        tokens.shift();
+        consumeWhitespace(tokens);
+        if (tokens.length == 0) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: '@' + atRule.nam,
+                error: 'expected container query-in-parens',
+                tokens
+            };
+        }
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@' + atRule.nam,
+        error: '',
+        tokens
+    };
+}
+
+export { validateAtRuleContainer };