@master/css 2.0.0-rc.60 → 2.0.0-rc.62

package/dist/utils/parse-selector.mjs

@@ -0,0 +1,110 @@
+import { SELECTOR_COMBINATORS } from '../common.mjs';
+import MasterCSS from '../core.mjs';
+import parsePair from './parse-pair.mjs';
+
+const SELECTOR_REGEX = new RegExp(`(?:[a-zA-Z0-9-]+)|([${SELECTOR_COMBINATORS.join('')}.:,])|(a-zA-Z0-9-)`, 'g');
+function parseSelector(token, css = new MasterCSS(), isRaw = true) {
+    const resolve = (eachToken)=>{
+        const nodes = [];
+        let currentPrefix = '';
+        let tokenIndex = 0;
+        for (const match of eachToken.matchAll(SELECTOR_REGEX)){
+            const raw = match[0];
+            tokenIndex += raw.length;
+            if (raw === ':' || raw === '.') {
+                currentPrefix += raw;
+                continue;
+            }
+            let type;
+            let value = raw;
+            const definedNodes = css.selectors.get(currentPrefix + raw);
+            if (definedNodes) {
+                const firstNode = definedNodes[definedNodes.length - 1];
+                nodes.push(definedNodes.length === 1 && firstNode.type ? {
+                    ...firstNode,
+                    raw: currentPrefix + raw
+                } : {
+                    children: definedNodes,
+                    raw: currentPrefix + raw
+                });
+                currentPrefix = '';
+                continue;
+            }
+            if (SELECTOR_COMBINATORS.includes(raw)) {
+                type = 'combinator';
+                if (raw === '_') {
+                    const nextRawValue = eachToken[tokenIndex];
+                    const prevRawValue = eachToken[tokenIndex - raw.length - 1];
+                    if (prevRawValue !== '_' && nextRawValue !== '_') {
+                        value = ' ' // support BEM __
+                        ;
+                    }
+                }
+            } else if (raw === ',') {
+                type = 'separator';
+            } else if (currentPrefix === ':') {
+                type = 'pseudo-class';
+            } else if (currentPrefix === '::') {
+                type = 'pseudo-element';
+            } else if (currentPrefix === '.') {
+                type = 'class';
+            }
+            nodes.push({
+                value,
+                ...isRaw && {
+                    raw: currentPrefix + raw
+                },
+                ...type && {
+                    type
+                }
+            });
+            currentPrefix = '';
+        }
+        return nodes;
+    };
+    const pair = (eachToken, nodes = [])=>{
+        const paired = parsePair(eachToken);
+        if (paired) {
+            let { pre, body, post } = paired;
+            let name;
+            if (body) {
+                const lastColonIndex = pre.lastIndexOf(':');
+                if (lastColonIndex !== -1) {
+                    name = pre.slice(lastColonIndex);
+                    pre = pre.slice(0, lastColonIndex);
+                }
+            }
+            if (pre) nodes.push(...pair(pre));
+            if (body) {
+                const children = pair(body);
+                if (name) {
+                    const node = resolve(name)[0];
+                    if (children.length) node.children = children;
+                    nodes.push(node);
+                } else {
+                    nodes.push(...children);
+                }
+            }
+            if (post) nodes.push(...pair(post));
+            return nodes;
+        }
+        const attrPaired = parsePair(eachToken, '[', ']');
+        if (attrPaired) {
+            const { pre, body, post } = attrPaired;
+            if (pre) nodes.push(...pair(pre));
+            nodes.push({
+                value: body,
+                type: 'attribute',
+                ...isRaw && {
+                    raw: `[${body}]`
+                }
+            });
+            if (post) nodes.push(...pair(post));
+            return nodes;
+        }
+        return resolve(eachToken);
+    };
+    return pair(token);
+}
+
+export { parseSelector as default };

package/dist/utils/parse-value.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var common = require('../common.cjs');
+
+function parseValue(token, unit = '', rootSize = 1) {
+    const isNumber = typeof token === 'number';
+    const defaultUnit = unit;
+    // 如果是純數字
+    if (isNumber) {
+        return {
+            unit: defaultUnit,
+            type: 'number',
+            value: defaultUnit === 'rem' || defaultUnit === 'em' ? token / rootSize : token
+        };
+    }
+    const matches = token.match(common.UNIT_REGEX);
+    if (matches) {
+        let value = parseFloat(matches[1]);
+        let parsedUnit = matches[2] || '';
+        if (!parsedUnit && (defaultUnit === 'rem' || defaultUnit === 'em')) {
+            value = value / rootSize;
+            parsedUnit = defaultUnit;
+        }
+        return {
+            token,
+            value,
+            unit: parsedUnit || defaultUnit,
+            type: 'number'
+        };
+    }
+    // 無法解析則當作純字串
+    return {
+        token,
+        value: token,
+        type: 'string'
+    };
+}
+
+module.exports = parseValue;

package/dist/utils/parse-value.d.ts

@@ -0,0 +1,2 @@
+import { NumberValueComponent, StringValueComponent } from '../types/syntax';
+export default function parseValue(token: string | number, unit?: string, rootSize?: number): StringValueComponent | NumberValueComponent;

package/dist/utils/parse-value.mjs

@@ -0,0 +1,37 @@
+import { UNIT_REGEX } from '../common.mjs';
+
+function parseValue(token, unit = '', rootSize = 1) {
+    const isNumber = typeof token === 'number';
+    const defaultUnit = unit;
+    // 如果是純數字
+    if (isNumber) {
+        return {
+            unit: defaultUnit,
+            type: 'number',
+            value: defaultUnit === 'rem' || defaultUnit === 'em' ? token / rootSize : token
+        };
+    }
+    const matches = token.match(UNIT_REGEX);
+    if (matches) {
+        let value = parseFloat(matches[1]);
+        let parsedUnit = matches[2] || '';
+        if (!parsedUnit && (defaultUnit === 'rem' || defaultUnit === 'em')) {
+            value = value / rootSize;
+            parsedUnit = defaultUnit;
+        }
+        return {
+            token,
+            value,
+            unit: parsedUnit || defaultUnit,
+            type: 'number'
+        };
+    }
+    // 無法解析則當作純字串
+    return {
+        token,
+        value: token,
+        type: 'string'
+    };
+}
+
+export { parseValue as default };

package/dist/utils/replace-char-outside-quotes.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+function replaceCharOutsideQuotes(str, target, replace) {
+    let result = '';
+    let inSingle = false;
+    let inDouble = false;
+    for(let i = 0; i < str.length; i++){
+        const char = str[i];
+        const prev = str[i - 1];
+        if (char === '\'' && prev !== '\\' && !inDouble) inSingle = !inSingle;
+        else if (char === '"' && prev !== '\\' && !inSingle) inDouble = !inDouble;
+        if (char === target && !inSingle && !inDouble) {
+            result += replace;
+        } else {
+            result += char;
+        }
+    }
+    return result;
+}
+
+module.exports = replaceCharOutsideQuotes;

package/dist/utils/replace-char-outside-quotes.d.ts

@@ -0,0 +1 @@
+export default function replaceCharOutsideQuotes(str: string, target: string, replace: string): string;

package/dist/utils/replace-char-outside-quotes.mjs

@@ -0,0 +1,19 @@
+function replaceCharOutsideQuotes(str, target, replace) {
+    let result = '';
+    let inSingle = false;
+    let inDouble = false;
+    for(let i = 0; i < str.length; i++){
+        const char = str[i];
+        const prev = str[i - 1];
+        if (char === '\'' && prev !== '\\' && !inDouble) inSingle = !inSingle;
+        else if (char === '"' && prev !== '\\' && !inSingle) inDouble = !inDouble;
+        if (char === target && !inSingle && !inDouble) {
+            result += replace;
+        } else {
+            result += char;
+        }
+    }
+    return result;
+}
+
+export { replaceCharOutsideQuotes as default };

package/dist/utils/sort-readable-classes.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+var syntaxRuleType = require('../syntax-rule-type.cjs');
+var core = require('../core.cjs');
+var compareRulePriority = require('./compare-rule-priority.cjs');
+
+/**
+ * Sorts classes in a consistent order
+ * @param classes
+ * @param options
+ * @returns consistent classes
+ */ function sortReadableClasses(classes, css = new core()) {
+    css.add(...classes);
+    // 先去重 fixedClass for componentsLayer
+    const seenFixed = new Set();
+    const dedupedComponentRules = css.componentsLayer.rules.filter((rule)=>{
+        if (!rule.fixedClass) return true;
+        if (seenFixed.has(rule.fixedClass)) return false;
+        seenFixed.add(rule.fixedClass);
+        return true;
+    });
+    const allRules = [
+        ...dedupedComponentRules,
+        ...css.generalLayer.rules,
+        ...css.baseLayer.rules,
+        ...css.presetLayer.rules
+    ];
+    const baseSet = new Set(css.baseLayer.rules);
+    const presetSet = new Set(css.presetLayer.rules);
+    const getGroupIndex = (rule)=>{
+        if (baseSet.has(rule)) return 4;
+        if (presetSet.has(rule)) return 5;
+        if (rule.atRules) return 3;
+        if (rule.mode) return 2;
+        if (rule.selectorNodes?.length) return 1;
+        return 0;
+    };
+    const getTypeScore = (rule)=>{
+        if (rule.fixedClass) return 0;
+        if (rule.type === syntaxRuleType.Utility) return 1;
+        return 2;
+    };
+    const rulesWithSortKey = allRules.map((rule)=>({
+            rule,
+            sortKey: [
+                getGroupIndex(rule),
+                getTypeScore(rule)
+            ]
+        }));
+    const sortedRules = rulesWithSortKey.sort((a, b)=>{
+        for(let i = 0; i < a.sortKey.length; i++){
+            if (a.sortKey[i] !== b.sortKey[i]) {
+                return a.sortKey[i] - b.sortKey[i];
+            }
+        }
+        if (a.rule.fixedClass && b.rule.fixedClass) {
+            return a.rule.fixedClass.localeCompare(b.rule.fixedClass, undefined, {
+                numeric: true
+            });
+        }
+        return compareRulePriority.default(a.rule, b.rule);
+    });
+    const orderedClasses = sortedRules.map((entry)=>entry.rule.fixedClass || entry.rule.name);
+    const unknownClasses = classes.filter((className)=>orderedClasses.indexOf(className) === -1).sort((a, b)=>a.localeCompare(b, undefined, {
+            numeric: true
+        }));
+    css.remove(...classes);
+    return [
+        ...orderedClasses,
+        ...unknownClasses
+    ];
+}
+
+module.exports = sortReadableClasses;

package/dist/utils/{reorder-for-readable-classes.d.ts → sort-readable-classes.d.ts}

@@ -5,4 +5,4 @@ import MasterCSS from '../core';
  * @param options
  * @returns consistent classes
  */
-export default function reorderForReadableClasses(classes: string[], css?: MasterCSS): string[];
+export default function sortReadableClasses(classes: string[], css?: MasterCSS): string[];

package/dist/utils/sort-readable-classes.mjs

@@ -0,0 +1,72 @@
+import SyntaxRuleType from '../syntax-rule-type.mjs';
+import MasterCSS from '../core.mjs';
+import compareRulePriority from './compare-rule-priority.mjs';
+
+/**
+ * Sorts classes in a consistent order
+ * @param classes
+ * @param options
+ * @returns consistent classes
+ */ function sortReadableClasses(classes, css = new MasterCSS()) {
+    css.add(...classes);
+    // 先去重 fixedClass for componentsLayer
+    const seenFixed = new Set();
+    const dedupedComponentRules = css.componentsLayer.rules.filter((rule)=>{
+        if (!rule.fixedClass) return true;
+        if (seenFixed.has(rule.fixedClass)) return false;
+        seenFixed.add(rule.fixedClass);
+        return true;
+    });
+    const allRules = [
+        ...dedupedComponentRules,
+        ...css.generalLayer.rules,
+        ...css.baseLayer.rules,
+        ...css.presetLayer.rules
+    ];
+    const baseSet = new Set(css.baseLayer.rules);
+    const presetSet = new Set(css.presetLayer.rules);
+    const getGroupIndex = (rule)=>{
+        if (baseSet.has(rule)) return 4;
+        if (presetSet.has(rule)) return 5;
+        if (rule.atRules) return 3;
+        if (rule.mode) return 2;
+        if (rule.selectorNodes?.length) return 1;
+        return 0;
+    };
+    const getTypeScore = (rule)=>{
+        if (rule.fixedClass) return 0;
+        if (rule.type === SyntaxRuleType.Utility) return 1;
+        return 2;
+    };
+    const rulesWithSortKey = allRules.map((rule)=>({
+            rule,
+            sortKey: [
+                getGroupIndex(rule),
+                getTypeScore(rule)
+            ]
+        }));
+    const sortedRules = rulesWithSortKey.sort((a, b)=>{
+        for(let i = 0; i < a.sortKey.length; i++){
+            if (a.sortKey[i] !== b.sortKey[i]) {
+                return a.sortKey[i] - b.sortKey[i];
+            }
+        }
+        if (a.rule.fixedClass && b.rule.fixedClass) {
+            return a.rule.fixedClass.localeCompare(b.rule.fixedClass, undefined, {
+                numeric: true
+            });
+        }
+        return compareRulePriority(a.rule, b.rule);
+    });
+    const orderedClasses = sortedRules.map((entry)=>entry.rule.fixedClass || entry.rule.name);
+    const unknownClasses = classes.filter((className)=>orderedClasses.indexOf(className) === -1).sort((a, b)=>a.localeCompare(b, undefined, {
+            numeric: true
+        }));
+    css.remove(...classes);
+    return [
+        ...orderedClasses,
+        ...unknownClasses
+    ];
+}
+
+export { sortReadableClasses as default };

package/dist/utils/split-char-outside-quotes.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+function splitCharOutsideQuotes(str, char) {
+    const result = [];
+    let current = '';
+    let inSingle = false;
+    let inDouble = false;
+    for(let i = 0; i < str.length; i++){
+        const c = str[i];
+        const prev = str[i - 1];
+        // 處理 quote 開關
+        if (c === '\'' && !inDouble && prev !== '\\') {
+            inSingle = !inSingle;
+        } else if (c === '"' && !inSingle && prev !== '\\') {
+            inDouble = !inDouble;
+        }
+        // 在引號之外遇到目標字元就切分
+        if (c === char && !inSingle && !inDouble) {
+            result.push(current.trim());
+            current = '';
+        } else {
+            current += c;
+        }
+    }
+    if (current) result.push(current.trim());
+    return result;
+}
+
+module.exports = splitCharOutsideQuotes;

package/dist/utils/split-char-outside-quotes.d.ts

@@ -0,0 +1 @@
+export default function splitCharOutsideQuotes(str: string, char: string): string[];

package/dist/utils/split-char-outside-quotes.mjs

@@ -0,0 +1,27 @@
+function splitCharOutsideQuotes(str, char) {
+    const result = [];
+    let current = '';
+    let inSingle = false;
+    let inDouble = false;
+    for(let i = 0; i < str.length; i++){
+        const c = str[i];
+        const prev = str[i - 1];
+        // 處理 quote 開關
+        if (c === '\'' && !inDouble && prev !== '\\') {
+            inSingle = !inSingle;
+        } else if (c === '"' && !inSingle && prev !== '\\') {
+            inDouble = !inDouble;
+        }
+        // 在引號之外遇到目標字元就切分
+        if (c === char && !inSingle && !inDouble) {
+            result.push(current.trim());
+            current = '';
+        } else {
+            current += c;
+        }
+    }
+    if (current) result.push(current.trim());
+    return result;
+}
+
+export { splitCharOutsideQuotes as default };

package/dist/variable-rule.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class VariableRule {
+    name;
+    variable;
+    css;
+    nodes;
+    constructor(name, variable, css){
+        this.name = name;
+        this.variable = variable;
+        this.css = css;
+        this.nodes = [];
+        const hasDefaultValue = variable.value !== undefined;
+        if (hasDefaultValue) {
+            this.nodes.push(new VariableRuleNode(this.name, variable, css));
+        }
+        if (variable.modes) {
+            for(const mode in variable.modes){
+                const modeVariable = variable.modes[mode];
+                const variableRule = new VariableRuleNode(this.name, modeVariable, css, mode);
+                if (variableRule.modeTrigger) {
+                    const isDefaultMode = hasDefaultValue ? false : this.css.config.defaultMode === mode;
+                    variableRule.isDefaultMode = isDefaultMode;
+                    if (isDefaultMode) {
+                        this.nodes.unshift(variableRule);
+                    } else {
+                        this.nodes.push(variableRule);
+                    }
+                }
+            }
+        }
+    }
+    get key() {
+        return this.name;
+    }
+    get text() {
+        return this.nodes.map(({ text })=>text).join('');
+    }
+}
+class VariableRuleNode {
+    name;
+    variable;
+    css;
+    mode;
+    native;
+    isDefaultMode;
+    constructor(name, variable, css, mode){
+        this.name = name;
+        this.variable = variable;
+        this.css = css;
+        this.mode = mode;
+        this.isDefaultMode = false;
+    }
+    get modeTrigger() {
+        return this.mode ? this.css.config.modes?.[this.mode] : undefined;
+    }
+    get selectorText() {
+        const isDefaultMode = this.isDefaultMode;
+        if (this.mode) {
+            switch(this.modeTrigger){
+                case 'media':
+                    return ':root';
+                case 'host':
+                    return `:host(.${this.mode})` + (isDefaultMode ? ',:host' : '');
+                case 'class':
+                    return `.${this.mode}` + (isDefaultMode ? ',:root' : '');
+                default:
+                    return '';
+            }
+        } else {
+            return ':root';
+        }
+    }
+    get text() {
+        let text = `${this.selectorText}{--${this.name}:${String(this.variable.value)}}`;
+        if (this.modeTrigger === 'media') {
+            text = `@media (prefers-color-scheme:${this.mode}){${text}}`;
+        }
+        return text;
+    }
+}
+
+exports.VariableRuleNode = VariableRuleNode;
+exports.default = VariableRule;

package/dist/variable-rule.d.ts

@@ -0,0 +1,23 @@
+import MasterCSS from './core';
+import { LiteralVariable, Variable } from './types/syntax';
+export default class VariableRule {
+    readonly name: string;
+    readonly variable: Variable;
+    readonly css: MasterCSS;
+    nodes: VariableRuleNode[];
+    constructor(name: string, variable: Variable, css: MasterCSS);
+    get key(): string;
+    get text(): string;
+}
+export declare class VariableRuleNode {
+    readonly name: string;
+    readonly variable: LiteralVariable;
+    readonly css: MasterCSS;
+    readonly mode?: string | undefined;
+    native?: CSSRule;
+    isDefaultMode: boolean;
+    constructor(name: string, variable: LiteralVariable, css: MasterCSS, mode?: string | undefined);
+    get modeTrigger(): false | "class" | "media" | "host" | undefined;
+    get selectorText(): string;
+    get text(): string;
+}

package/dist/variable-rule.mjs

@@ -0,0 +1,81 @@
+class VariableRule {
+    name;
+    variable;
+    css;
+    nodes;
+    constructor(name, variable, css){
+        this.name = name;
+        this.variable = variable;
+        this.css = css;
+        this.nodes = [];
+        const hasDefaultValue = variable.value !== undefined;
+        if (hasDefaultValue) {
+            this.nodes.push(new VariableRuleNode(this.name, variable, css));
+        }
+        if (variable.modes) {
+            for(const mode in variable.modes){
+                const modeVariable = variable.modes[mode];
+                const variableRule = new VariableRuleNode(this.name, modeVariable, css, mode);
+                if (variableRule.modeTrigger) {
+                    const isDefaultMode = hasDefaultValue ? false : this.css.config.defaultMode === mode;
+                    variableRule.isDefaultMode = isDefaultMode;
+                    if (isDefaultMode) {
+                        this.nodes.unshift(variableRule);
+                    } else {
+                        this.nodes.push(variableRule);
+                    }
+                }
+            }
+        }
+    }
+    get key() {
+        return this.name;
+    }
+    get text() {
+        return this.nodes.map(({ text })=>text).join('');
+    }
+}
+class VariableRuleNode {
+    name;
+    variable;
+    css;
+    mode;
+    native;
+    isDefaultMode;
+    constructor(name, variable, css, mode){
+        this.name = name;
+        this.variable = variable;
+        this.css = css;
+        this.mode = mode;
+        this.isDefaultMode = false;
+    }
+    get modeTrigger() {
+        return this.mode ? this.css.config.modes?.[this.mode] : undefined;
+    }
+    get selectorText() {
+        const isDefaultMode = this.isDefaultMode;
+        if (this.mode) {
+            switch(this.modeTrigger){
+                case 'media':
+                    return ':root';
+                case 'host':
+                    return `:host(.${this.mode})` + (isDefaultMode ? ',:host' : '');
+                case 'class':
+                    return `.${this.mode}` + (isDefaultMode ? ',:root' : '');
+                default:
+                    return '';
+            }
+        } else {
+            return ':root';
+        }
+    }
+    get text() {
+        let text = `${this.selectorText}{--${this.name}:${String(this.variable.value)}}`;
+        if (this.modeTrigger === 'media') {
+            text = `@media (prefers-color-scheme:${this.mode}){${text}}`;
+        }
+        return text;
+    }
+}
+
+export { VariableRuleNode, VariableRule as default };

package/package.json

@@ -1 +1 @@
-{"name":"@master/css","type":"module","scripts":{"build":"techor build \"src/**/*.ts\"","dev":"pnpm build --watch","test":"vitest","type-check":"tsc --noEmit","lint":"eslint"},"license":"MIT","description":"The CSS language and framework for rapidly building modern and high-performance websites","author":"Aoyue Design LLC.","funding":"https://rc.css.master.co/sponsor","homepage":"https://css.master.co","bugs":{"url":"https://github.com/master-co/css/issues"},"repository":{"type":"git","url":"https://github.com/master-co/css.git","directory":"packages/core"},"keywords":["style","styles","html","variants","virtual","virtual-css","utility","css","ui","lightweight","class","webpack","plugin","integration","vite","parcel","build-tools","mastercss"],"sideEffects":false,"main":"./dist/index.cjs","jsnext:main":"./dist/index.mjs","esnext":"./dist/index.mjs","module":"./dist/index.mjs","types":"./dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","require":"./dist/index.cjs","import":"./dist/index.mjs"}},"bin":"./dist/bin/index.mjs","files":["dist"],"publishConfig":{"access":"public","provenance":true},"dependencies":{"@master/colors":"^2.1.0","@master/normal.css":"^3.1.0","@techor/extend":"^3.2.0","csstype":"^3.1.3"},"devDependencies":{"shared":"^2.0.0-rc.60"},"version":"2.0.0-rc.60"}
+{"name":"@master/css","type":"module","scripts":{"build":"techor build \"src/**/*.ts\"","dev":"pnpm build --watch","test":"vitest","type-check":"tsc --noEmit","lint":"eslint"},"license":"MIT","description":"The CSS language and framework for rapidly building modern and high-performance websites","author":"Aoyue Design LLC.","funding":"https://rc.css.master.co/sponsor","homepage":"https://css.master.co","bugs":{"url":"https://github.com/master-co/css/issues"},"repository":{"type":"git","url":"https://github.com/master-co/css.git","directory":"packages/core"},"keywords":["style","styles","html","variants","virtual","virtual-css","utility","css","ui","lightweight","class","webpack","plugin","integration","vite","parcel","build-tools","mastercss"],"sideEffects":false,"main":"./dist/index.cjs","jsnext:main":"./dist/index.mjs","esnext":"./dist/index.mjs","module":"./dist/index.mjs","types":"./dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","require":"./dist/index.cjs","import":"./dist/index.mjs"}},"bin":"./dist/bin/index.mjs","files":["dist"],"publishConfig":{"access":"public","provenance":true},"dependencies":{"@master/colors":"^2.1.1","@master/normal.css":"^3.1.0","@techor/extend":"^3.2.0","csstype":"^3.1.3"},"devDependencies":{"shared":"^2.0.0-rc.62"},"version":"2.0.0-rc.62"}

package/dist/utils/are-rule-at-equal.cjs

@@ -1,22 +0,0 @@
-'use strict';
-
-function areRuleAtEqual(aSyntaxRule, bSyntaxRule) {
-    const aQueryTypes = Object.keys(aSyntaxRule.at);
-    const bQueryTypes = Object.keys(bSyntaxRule.at);
-    if (aQueryTypes.length !== bQueryTypes.length) {
-        return false;
-    }
-    for (const aQueryType of aQueryTypes){
-        const aAtComponents = aSyntaxRule.at[aQueryType];
-        const bAtComponents = bSyntaxRule.at[aQueryType];
-        for (const aAtComponent of aAtComponents){
-            const aAtComponentToken = aSyntaxRule.resolveAtComponent(aAtComponent);
-            if (!bAtComponents.find((bAtComponent)=>bSyntaxRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-module.exports = areRuleAtEqual;