add missing files #47

Author: tbela99

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

@@ -0,0 +1,72 @@
+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';
+
+function validateAtRuleCounterStyle(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@counter-style',
+            error: 'expected media query list',
+            tokens: []
+        };
+    }
+    const tokens = atRule.tokens.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@counter-style',
+            error: 'expected counter style name',
+            tokens
+        };
+    }
+    if (tokens.length > 1) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[1] ?? atRule,
+            syntax: '@counter-style',
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    if (![EnumToken.IdenTokenType, EnumToken.DashedIdenTokenType].includes(tokens[0].typ)) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: '@counter-style',
+            error: 'expected counter style name',
+            tokens
+        };
+    }
+    if (!('chi' in atRule)) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@counter-style',
+            error: 'expected counter style body',
+            tokens
+        };
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@counter-style',
+        error: '',
+        tokens
+    };
+}
+
+export { validateAtRuleCounterStyle };

dist/lib/validation/at-rules/document.js

@@ -0,0 +1,107 @@
+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 { validateURL } from '../syntaxes/url.js';
+
+function validateAtRuleDocument(atRule, options, root) {
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@document',
+            error: 'expecting at-rule prelude',
+            tokens: []
+        };
+    }
+    const tokens = atRule.tokens.slice();
+    let result = null;
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@document',
+            error: 'expecting at-rule prelude',
+            tokens
+        };
+    }
+    if (tokens[0].typ == EnumToken.CommaTokenType) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: '@document',
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    while (tokens.length > 0) {
+        if (tokens[0].typ == EnumToken.CommentTokenType) {
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        result = validateURL(tokens[0]);
+        if (result.valid == ValidationLevel.Valid) {
+            tokens.shift();
+            consumeWhitespace(tokens);
+            continue;
+        }
+        if (tokens[0].typ == EnumToken.FunctionTokenType) {
+            if (!['url-prefix', 'domain', 'media-document', 'regexp'].some((t) => t.localeCompare(tokens[0].val, undefined, { sensitivity: 'base' }) == 0)) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@document',
+                    error: 'unexpected token',
+                    tokens
+                };
+            }
+            const children = tokens[0].chi.slice();
+            consumeWhitespace(children);
+            if (children.length == 0) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@document',
+                    error: 'expecting string argument',
+                    tokens
+                };
+            }
+            if (children[0].typ == EnumToken.StringTokenType) {
+                children.shift();
+                consumeWhitespace(children);
+            }
+            if (children.length > 0) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: children[0],
+                    syntax: '@document',
+                    error: 'unexpected token',
+                    tokens
+                };
+            }
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@document',
+        error: '',
+        tokens
+    };
+}
+
+export { validateAtRuleDocument };

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

@@ -0,0 +1,46 @@
+import { ValidationLevel } 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 { validateFamilyName } from '../syntaxes/family-name.js';
+import '../syntaxes/complex-selector.js';
+
+function validateAtRuleFontFeatureValues(atRule, options, root) {
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: null,
+            syntax: '@' + atRule.nam,
+            error: 'expected at-rule prelude',
+            tokens: []
+        };
+    }
+    const result = validateFamilyName(atRule.tokens, atRule);
+    if (result.valid == ValidationLevel.Drop) {
+        return result;
+    }
+    if (!('chi' in atRule)) {
+        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: []
+    };
+}
+
+export { validateAtRuleFontFeatureValues };