@jesscss/core 2.0.0-alpha.1

package/lib/tree/import-style.js

@@ -0,0 +1,556 @@
+import { Node, F_MAY_ASYNC, F_NON_STATIC, F_VISIBLE, defineType } from './node.js';
+import { Rules } from './rules.js';
+import { isThenable } from '@jesscss/awaitable-pipe';
+import { isNode } from './util/is-node.js';
+import { AtRule } from './at-rule.js';
+import { Any } from './any.js';
+/**
+ * This is a generic class for:
+ *   - Sass+ `@use` (for stylesheets)
+ *   - Jess `@-compose` and Less `@compose`
+ *   - Less, Sass+, and Jess `@import` / `@-import` that are indicated
+ *     to be processed by the engine
+ *
+ * @see https://sass-lang.com/documentation/at-rules/import/
+ */
+export class StyleImport extends Node {
+    type = 'StyleImport';
+    shortType = 'style';
+    constructor(value, options, location, treeContext) {
+        super(value, options, location, treeContext);
+        // Style imports are always non-static and may be async
+        this.addFlags(F_MAY_ASYNC, F_NON_STATIC);
+    }
+    getFinalRules(evaluatedRules) {
+        let { importOptions, type } = this.options;
+        const reference = importOptions.reference;
+        const isForward = importOptions.forward === true;
+        // For compose type, default is protected (not mutable). For import type, default is mutable.
+        // mutable: false on @import explicitly makes it protected.
+        const isProtected = type === 'compose'
+            ? !importOptions.mutable // compose: protected unless mutable: true
+            : importOptions.mutable === false; // import: mutable unless explicitly mutable: false
+        let Ruleset = 'public';
+        let Declaration = 'public';
+        let Mixin = 'public';
+        let VarDeclaration = 'public';
+        if (isProtected) {
+            Ruleset = 'private';
+        }
+        else if (reference) {
+            /**
+             * Not sure if this is true.
+             * They won't be output, but that's not the same as being optional,
+             * UNLESS we're extending the word 'optional' to mean "not output".
+             *
+             * I think what we mean here by "optional" it "not ouptut unless extended".
+             * Our test for reference therefore should mimic Less behavior.
+             */
+            Ruleset = 'optional';
+        }
+        /**
+         * Create a rules wrapper so we can set visibility.
+         * The inner rules may be static, but the import may
+         * have different import settings.
+         *
+         * For compose type:
+         * - Variables and mixins are visible to the direct parent (the file that imports them)
+         * - If 'export' flag is set, variables and mixins are also forwarded to downstream stylesheets
+         * - The 'local' flag means: visible to direct parent, but not re-exported to parent's parent
+         */
+        const isReferenceMode = ((type === 'import' && (importOptions?._dedupe === true || reference))
+            || (type === 'compose' && reference));
+        // De-duped imports mutate node options during markReferenceMode; use deep clone so
+        // repeated imports do not retroactively mutate previously emitted import trees.
+        // Keep explicit reference imports on shallow clone to preserve existing extend wiring.
+        const useDeepClone = Boolean(type === 'import'
+            && (importOptions.multiple === true || importOptions._dedupe === true));
+        let out = (useDeepClone ? evaluatedRules.clone(true) : evaluatedRules.clone());
+        // Import type: variables are visible and re-exported (not local)
+        // Compose type: variables are visible to parent but not transitive by default (`local: true`)
+        // Forward: not visible locally but *is* transitive (`local: false`)
+        const isLocal = type === 'compose' && !isForward;
+        out.options = {
+            rulesVisibility: { Ruleset, Declaration, Mixin, VarDeclaration },
+            local: isLocal,
+            forward: isForward,
+            referenceMode: isReferenceMode,
+            readonly: importOptions.readonly ?? (type === 'compose' ? true : false)
+        };
+        if (isReferenceMode) {
+            const markReferenceMode = (node) => {
+                const nodeOptions = node.options;
+                nodeOptions.referenceMode = true;
+                const maybeRulesValue = node.value;
+                const rules = maybeRulesValue?.rules;
+                if (rules && isNode(rules, 'Rules')) {
+                    markReferenceMode(rules);
+                }
+                const children = node.value;
+                if (Array.isArray(children)) {
+                    for (const child of children) {
+                        if (isNode(child, ['Rules', 'Ruleset', 'AtRule'])) {
+                            markReferenceMode(child);
+                        }
+                    }
+                }
+            };
+            markReferenceMode(out);
+        }
+        // Forwarded modules should never render output at this scope.
+        if (isForward) {
+            out.removeFlag(F_VISIBLE);
+        }
+        // Set sourceNode so variable lookups know they can cross import boundaries
+        out.sourceNode = this;
+        this.adopt(out);
+        return out;
+    }
+    /**
+     * Defer import-path interpolation to evalNode so unresolved vars can be retried
+     * after later imports/assignments in the same Rules scope have evaluated.
+     */
+    preEval(_context) {
+        return this;
+    }
+    /**
+     * @note
+     * When imports are evaluated, they should be deeply cloned. The reason is that
+     * they can be used in multiple places, and can be evaluated differently
+     * each time, so they are more like a function call.
+     *
+     * @todo
+     * How do extends work then?
+     */
+    evalNode(context) {
+        let node = this;
+        const { path, with: withValues } = node.value;
+        const { options } = node;
+        options.importOptions ??= {};
+        const { type, importOptions } = options;
+        const maybePath = path.eval(context);
+        let originalDepth = context.depth;
+        context.depth = this.depth;
+        /**
+         * @todo - Add options
+         *
+         * Note that the Less plugin should trigger a unique default behavior
+         * for `@import` which is that it is de-duplicated by default. Meaning
+         * that it won't render rulesets twice per compilation. I think that
+         * means that it's just kind of ignored without an explicit `multiple`
+         * option. Since all vars are global per compilation, it should just
+         * work.
+         */
+        const finalize = async (finalPath) => {
+            const previousTreeContext = context.treeContext;
+            // Inherit "reference branch" semantics lexically for nested imports unless
+            // `multiple` explicitly opts into fresh output.
+            const inheritedReferenceMode = context.inReferenceImportScope;
+            const previousExplicitReference = importOptions.reference;
+            let pushedImportScope = false;
+            if (inheritedReferenceMode && !importOptions.multiple) {
+                importOptions.reference = true;
+            }
+            if (node.treeContext) {
+                context.treeContext = node.treeContext;
+            }
+            if (importOptions.multiple || importOptions.reference) {
+                // Scope push/pop is intentionally paired in this method's try/finally.
+                // This keeps branch semantics local to this import evaluation path.
+                context.pushImportScope({
+                    multiple: importOptions.multiple === true,
+                    reference: importOptions.reference === true
+                });
+                pushedImportScope = true;
+            }
+            try {
+                const isInlineImport = importOptions.inline === true;
+                let rules;
+                let resolvedPath;
+                if (isInlineImport) {
+                    const resolved = await context.resolveImportPath(finalPath);
+                    resolvedPath = resolved.resolvedPath;
+                    const sourceGetter = context.plugins.find(plugin => plugin.getSource);
+                    if (!sourceGetter) {
+                        throw new Error('No source getter found');
+                    }
+                    const source = await sourceGetter.getSource(resolvedPath);
+                    const sourceNode = new Any(source, { role: 'any' });
+                    rules = this.wrapInlineSourceWithPostlude(sourceNode, importOptions.postlude);
+                }
+                else {
+                    try {
+                        ({ node: rules, resolvedPath } = await context.getTree(finalPath, importOptions));
+                    }
+                    catch (error) {
+                        if (importOptions.optional) {
+                            return Rules.create([]);
+                        }
+                        if (importOptions.reference && (error?.phase === 'parse' || String(error?.code ?? '').startsWith('parse/'))) {
+                            return Rules.create([]);
+                        }
+                        throw error;
+                    }
+                }
+                // Set sourceNode immediately after getting the Rules, before any evaluation
+                // This ensures that when preEval clones the Rules, the cloned Rules will have sourceNode set
+                // and registerNode can detect this is an imported Rules
+                rules.sourceNode = node;
+                let evaldRules = context.evaldTrees.get(resolvedPath);
+                // Compose caching semantics:
+                // - The first time a module is composed, we evaluate and cache the evaluated Rules.
+                // - Subsequent compose imports reuse the cached evaluated Rules (so re-imports don't re-run evaluation).
+                // - Subsequent compose imports default to "reference" mode unless `multiple: true` is set,
+                //   so rulesets / at-rules are not output again.
+                if (type === 'compose' && evaldRules) {
+                    if (withValues) {
+                        // Sass-style: once configured, cannot be configured again.
+                        // (We keep parsing show/hide/prefix metadata elsewhere; this is for with/set configs.)
+                        throw new Error('Cannot configure a stylesheet more than once.');
+                    }
+                    // Reuse cached evaluated rules tree.
+                    rules = evaldRules;
+                    // Default: de-dupe output for compose re-imports unless explicitly multiple.
+                    if (!importOptions.multiple) {
+                        importOptions.reference = true;
+                    }
+                }
+                const inMultipleImportBranch = context.inMultipleImportScope;
+                if (type === 'import' && importOptions.once !== false && !importOptions.multiple && !inMultipleImportBranch && evaldRules) {
+                    rules = evaldRules;
+                    importOptions._dedupe = true;
+                }
+                if (withValues) {
+                    // Once configured, cannot be configured again (handled above for compose+cache).
+                    if (withValues.type === 'set' && evaldRules) {
+                        throw new Error('Cannot configure a stylesheet more than once.');
+                    }
+                    // Clone the imported rules BEFORE evaluation so registries are populated on the clone
+                    let modifiedRules = rules.clone(true);
+                    // withValues.node might be a Reference, so evaluate it first to get Rules
+                    let withRulesNode = withValues.node;
+                    if (isNode(withRulesNode, 'Reference')) {
+                        // Evaluate the reference to get the actual Rules
+                        const evaluated = await withRulesNode.eval(context);
+                        if (!isNode(evaluated, 'Collection')) {
+                            throw new Error('with/set node must evaluate to a Collection');
+                        }
+                        withRulesNode = evaluated;
+                    }
+                    // withRules don't need to be cloned because they are used once
+                    let withRules = withRulesNode;
+                    // Build the declaration registry for efficient lookups
+                    // This avoids O(n*m) complexity when we have many injected variables
+                    // First, register all nodes in modifiedRules so they're in the registry
+                    for (const node of modifiedRules.value) {
+                        modifiedRules.registerNode(node);
+                    }
+                    const declarationRegistry = modifiedRules.getRegistry('declaration');
+                    declarationRegistry.indexPendingItems();
+                    // Separate injected variables into two groups:
+                    // 1. Variables that replace existing ones (found in imported rules)
+                    // 2. Variables that are new (not found in imported rules)
+                    const newVariables = [];
+                    // For each injected variable, find and replace the first matching declaration
+                    // in the imported rules, OR if not found, add it to newVariables to inject at the top.
+                    // This ensures the injected value "overrides" the original.
+                    // Works correctly for both scope lookup ($var) and linear lookup ($^var):
+                    // - For linear lookup: injected vars come first, so they're found first
+                    // - For scope lookup: original is replaced, so injected value wins
+                    for (const injectedNode of withRules.value) {
+                        if (isNode(injectedNode, 'VarDeclaration')) {
+                            const varName = injectedNode.value.name?.toString();
+                            if (varName) {
+                                // Use the registry for efficient lookup instead of linear search
+                                const declarations = declarationRegistry.index.get(varName);
+                                if (declarations) {
+                                    // Find the first VarDeclaration in the set (sorted by index)
+                                    const existingDecl = Array.from(declarations).find(decl => isNode(decl, 'VarDeclaration'));
+                                    if (existingDecl) {
+                                        // Remove the old declaration from the registry
+                                        declarations.delete(existingDecl);
+                                        // Find its index in the array and replace it
+                                        const index = modifiedRules.value.indexOf(existingDecl);
+                                        if (index !== -1) {
+                                            // Adopt the new node and replace in array
+                                            modifiedRules.adopt(injectedNode);
+                                            modifiedRules.value[index] = injectedNode;
+                                            // Add the new declaration to the registry
+                                            declarations.add(injectedNode);
+                                            // Register the new node so it's properly indexed
+                                            modifiedRules.registerNode(injectedNode);
+                                        }
+                                    }
+                                    else {
+                                        // Not found, add to newVariables to inject at the top
+                                        newVariables.push(injectedNode);
+                                    }
+                                }
+                                else {
+                                    // Not found in registry, add to newVariables to inject at the top
+                                    newVariables.push(injectedNode);
+                                }
+                            }
+                            else {
+                                // Non-variable nodes (if any) are kept as-is
+                                newVariables.push(injectedNode);
+                            }
+                        }
+                        else {
+                            // Non-VarDeclaration nodes are kept as-is
+                            newVariables.push(injectedNode);
+                        }
+                    }
+                    // Create the final rules structure:
+                    // [new injected variables (not found in imported), ...all nodes from modified imported rules (with replacements)]
+                    // Injected variables that aren't found should be at the TOP so they're found first
+                    // for linear lookup ($^var)
+                    // We flatten the structure so all variables are in the same Rules scope
+                    const finalRules = Rules.create([]);
+                    // First, add new injected variables that weren't found in imported rules (at the top)
+                    for (const newNode of newVariables) {
+                        finalRules.adopt(newNode);
+                        finalRules.value.push(newNode);
+                    }
+                    // Then, add all nodes from the modified imported rules (flattened, with replacements)
+                    for (const node of modifiedRules.value) {
+                        finalRules.adopt(node);
+                        finalRules.value.push(node);
+                    }
+                    rules = finalRules;
+                }
+                // For compose type, register and push extend root BEFORE evaluation
+                // so extends inside the import use the correct root
+                const parentExtendRoot = context.extendRoots.getCurrentExtendRoot();
+                let pushedExtendRoot = false;
+                if (type === 'compose') {
+                    // Register the Rules as an extend root (use rules before cloning/evaluation)
+                    // We'll update the registration after evaluation if the Rules changes
+                    // For compose type, default is protected (not mutable)
+                    const isComposeProtected = !importOptions.mutable;
+                    context.extendRoots.registerRoot(rules, parentExtendRoot, {
+                        isProtected: isComposeProtected,
+                        isCompose: true,
+                        namespace: node.options.namespace
+                    });
+                    context.extendRoots.pushExtendRoot(rules);
+                    pushedExtendRoot = true;
+                }
+                /** Freshly evaluate the rules in these circumstances
+               * - `with` (or `set`) values are present
+               * - the rules have not been evaluated yet
+               * - the import type is `import`
+              */
+                let evaluatedInImplicitReferenceMode = false;
+                if (withValues || !evaldRules || type === 'import') {
+                    const preserveOriginalNodes = context.preserveOriginalNodes;
+                    context.preserveOriginalNodes = true;
+                    let pushedImplicitReferenceEvalScope = false;
+                    const isImplicitReferenceModeForEval = (type === 'import'
+                        && importOptions.reference !== true
+                        && importOptions._dedupe === true
+                        && !importOptions.multiple);
+                    if (isImplicitReferenceModeForEval) {
+                        evaluatedInImplicitReferenceMode = true;
+                        // Dedupe re-imports behave like an implicit reference traversal:
+                        // evaluate for symbol availability, but avoid outward extend side effects.
+                        context.pushImportScope({ reference: true });
+                        pushedImplicitReferenceEvalScope = true;
+                    }
+                    // For protected imports (mutable: false), push the rules to extend root stack
+                    // so rulesets register in the import's registry, not the parent's
+                    const isImportProtected = type === 'import' && importOptions.mutable === false;
+                    const shouldUseLocalExtendRoot = isImportProtected || isImplicitReferenceModeForEval;
+                    if (isImplicitReferenceModeForEval) {
+                        // Link local in-eval root so external extends can still target deduped imports.
+                        context.extendRoots.registerRoot(rules, parentExtendRoot, {
+                            isProtected: isImportProtected,
+                            namespace: node.options.namespace
+                        });
+                    }
+                    if (shouldUseLocalExtendRoot) {
+                        context.extendRoots.pushExtendRoot(rules);
+                    }
+                    try {
+                        // Call preEval first to get the cloned Rules (if cloning occurs)
+                        // sourceNode is already set above, so the cloned Rules will have it
+                        rules = await rules.preEval(context);
+                        if (type === 'import') {
+                            /** Needed at evaluation time for older import type */
+                            node.adopt(rules);
+                        }
+                        rules = await rules.eval(context);
+                    }
+                    finally {
+                        context.preserveOriginalNodes = preserveOriginalNodes;
+                        if (pushedImplicitReferenceEvalScope) {
+                            context.popImportScope();
+                        }
+                        if (shouldUseLocalExtendRoot) {
+                            context.extendRoots.popExtendRoot();
+                        }
+                    }
+                    // Cache compose modules (and configured modules) after first evaluation.
+                    if (type === 'compose'
+                        || withValues?.type === 'set'
+                        || (type === 'import' && importOptions.once !== false)) {
+                        context.evaldTrees.set(resolvedPath, rules);
+                    }
+                }
+                else {
+                    // Clone the unevaluated rules BEFORE evaluation so registries are populated on the clone
+                    // This ensures registration happens post-clone, not on the cached evaldRules
+                    // sourceNode is already set above, so the cloned Rules will have it
+                    rules = rules.clone(true);
+                    let preserveOriginalNodes = context.preserveOriginalNodes;
+                    context.preserveOriginalNodes = true;
+                    // Note: For compose type, we don't set rules.parent = node
+                    // (only import type needs this for older import behavior)
+                    rules = await rules.eval(context);
+                    context.preserveOriginalNodes = preserveOriginalNodes;
+                }
+                // Pop extend root if we pushed one
+                if (pushedExtendRoot) {
+                    context.extendRoots.popExtendRoot();
+                }
+                if (evaluatedInImplicitReferenceMode) {
+                    rules.options.referenceMode = false;
+                }
+                let finalRules = node.getFinalRules(rules);
+                if (evaluatedInImplicitReferenceMode) {
+                    finalRules.options.referenceMode = false;
+                }
+                if (importOptions.postlude && !isInlineImport) {
+                    finalRules = this.wrapEvaluatedRulesWithPostlude(finalRules, importOptions.postlude);
+                }
+                // For import type, register the final Rules as a child root of the parent
+                // so extends from the parent can find rulesets in the imported Rules
+                // Do this AFTER getFinalRules because it returns a cloned Rules
+                if (type === 'import') {
+                    const currentParentExtendRoot = context.extendRoots.getCurrentExtendRoot();
+                    // Import type is mutable by default (unless explicitly mutable: false)
+                    const isImportProtected = importOptions.mutable === false;
+                    const isImplicitReferenceModeForRegistration = (importOptions._dedupe === true
+                        && importOptions.reference !== true
+                        && !importOptions.multiple);
+                    const shouldReRegisterLocalRootRulesets = isImportProtected || isImplicitReferenceModeForRegistration;
+                    context.extendRoots.registerRoot(finalRules, currentParentExtendRoot, {
+                        isProtected: isImportProtected,
+                        namespace: node.options.namespace
+                    });
+                    // For imports that evaluated under a local extend root (protected import or implicit _dedupe
+                    // reference traversal), rulesets were registered in the pre-finalized Rules root. Since
+                    // getFinalRules can clone, re-register all descendant rulesets under finalRules.
+                    // during preEval (when we pushed rules to the stack). Since getFinalRules clones,
+                    // we need to re-register rulesets in finalRules' registry.
+                    if (shouldReRegisterLocalRootRulesets) {
+                        const finalRulesRegistry = finalRules.getRegistry('ruleset');
+                        for (const maybeRuleset of finalRules.nodes()) {
+                            if (isNode(maybeRuleset, 'Ruleset')) {
+                                finalRulesRegistry.add(maybeRuleset);
+                            }
+                        }
+                    }
+                    // Don't push to stack - import type uses parent's root for extends inside the import
+                    // But we register it so extends from parent can find rulesets in the imported Rules
+                }
+                return finalRules;
+            }
+            finally {
+                context.treeContext = previousTreeContext;
+                if (pushedImportScope) {
+                    context.popImportScope();
+                }
+                importOptions.reference = previousExplicitReference;
+            }
+        };
+        if (isThenable(maybePath)) {
+            return maybePath.then(async (p) => {
+                const finalPath = p.valueOf();
+                context.depth = originalDepth;
+                return finalize(finalPath);
+            });
+        }
+        const finalPath = maybePath.valueOf();
+        context.depth = originalDepth;
+        return finalize(finalPath);
+    }
+    /**
+     * Applies CSS import postlude wrappers around inline source content.
+     * Falls back to `@media <postlude>` for plain query nodes.
+     */
+    wrapInlineSourceWithPostlude(sourceNode, postlude) {
+        if (!postlude) {
+            return Rules.create([sourceNode]);
+        }
+        let wrapped = sourceNode;
+        const postludeNodes = isNode(postlude, ['Sequence', 'List']) ? postlude.value : [postlude];
+        for (let i = postludeNodes.length - 1; i >= 0; i--) {
+            const current = postludeNodes[i];
+            const body = Rules.create([wrapped]);
+            if (isNode(current, 'Call')) {
+                const callName = String(current.value.name).toLowerCase();
+                if (callName === 'media' || callName === 'supports' || callName === 'layer') {
+                    const args = current.value.args?.value ?? [];
+                    const prelude = args.length <= 1 ? args[0] : current.value.args;
+                    if (prelude) {
+                        wrapped = new AtRule({
+                            name: new Any(`@${callName}`, { role: 'atkeyword' }),
+                            prelude,
+                            rules: body
+                        });
+                        continue;
+                    }
+                }
+            }
+            wrapped = new AtRule({
+                name: new Any('@media', { role: 'atkeyword' }),
+                prelude: current,
+                rules: body
+            });
+        }
+        return Rules.create([wrapped]);
+    }
+    /**
+     * Applies CSS import postlude wrappers around evaluated stylesheet rules.
+     * Used for Less-style imports with media/layer/supports postludes.
+     */
+    wrapEvaluatedRulesWithPostlude(rules, postlude) {
+        if (!postlude) {
+            return rules;
+        }
+        const postludeNodes = isNode(postlude, ['Sequence', 'List']) ? postlude.value : [postlude];
+        let wrappedRules = rules;
+        for (let i = postludeNodes.length - 1; i >= 0; i--) {
+            const current = postludeNodes[i];
+            if (isNode(current, 'Call')) {
+                const callName = String(current.value.name).toLowerCase();
+                if (callName === 'media' || callName === 'supports' || callName === 'layer') {
+                    const args = current.value.args?.value ?? [];
+                    const prelude = args.length <= 1 ? args[0] : current.value.args;
+                    if (prelude) {
+                        const wrappedAtRule = new AtRule({
+                            name: new Any(`@${callName}`, { role: 'atkeyword' }),
+                            prelude,
+                            rules: wrappedRules
+                        });
+                        wrappedRules = Rules.create([wrappedAtRule]);
+                        continue;
+                    }
+                }
+            }
+            const mediaAtRule = new AtRule({
+                name: new Any('@media', { role: 'atkeyword' }),
+                prelude: current,
+                rules: wrappedRules
+            });
+            wrappedRules = Rules.create([mediaAtRule]);
+        }
+        return wrappedRules;
+    }
+}
+defineType(StyleImport, 'StyleImport', 'style');
+export const style = (...args) => {
+    return new StyleImport(...args);
+};
+//# sourceMappingURL=import-style.js.map

package/lib/tree/import-style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-style.js","sourceRoot":"","sources":["../../src/tree/import-style.ts"],"names":[],"mappings":"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"}

package/lib/tree/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @note
+ * These nodes are actually taking the role of two ASTs,
+ * because there are nodes that will be used to produce a module,
+ * and that module will create AST nodes to create CSS.
+ *
+ * @todo - rewrite the above, this is no longer true
+ */
+/**
+ * Import from node.ts which applies all the prototype patches
+ * (nil, operate, treeContext) and re-exports from node-base.ts
+ */
+import { Node, type LocationInfo, F_VISIBLE, F_MAY_ASYNC, F_STATIC, F_NON_STATIC } from './node.js';
+import { TreeContext } from '../context.js';
+export { Node, TreeContext, type LocationInfo, F_VISIBLE, F_MAY_ASYNC, F_STATIC, F_NON_STATIC };
+export * from './at-rule.js';
+export * from './block.js';
+export * from './bool.js';
+export * from './ampersand.js';
+export * from './any.js';
+export * from './call.js';
+export * from './color.js';
+export * from './comment.js';
+export * from './combinator.js';
+export * from './condition.js';
+export * from './control.js';
+export * from './declaration.js';
+export * from './declaration-custom.js';
+export * from './declaration-var.js';
+export * from './dimension.js';
+export * from './number.js';
+export * from './expression.js';
+export * from './extend.js';
+export * from './list.js';
+export * from './log.js';
+export * from './mixin.js';
+export * from './negative.js';
+export * from './function.js';
+export * from './js-function.js';
+export * from './js-array.js';
+export * from './js-object.js';
+export * from './nil.js';
+export * from './operation.js';
+export * from './paren.js';
+export * from './quoted.js';
+export * from './range.js';
+export * from './ruleset.js';
+export * from './rules.js';
+export * from './rules-raw.js';
+export * from './collection.js';
+export * from './selector.js';
+export * from './selector-attr.js';
+export * from './selector-basic.js';
+export * from './selector-list.js';
+export * from './selector-pseudo.js';
+export * from './selector-compound.js';
+export * from './selector-complex.js';
+export * from './selector-simple.js';
+export * from './selector-capture.js';
+export * from './sequence.js';
+export * from './query-condition.js';
+export * from './comment.js';
+export * from './reference.js';
+export * from './import-style.js';
+export * from './import-js.js';
+export * from './interpolated.js';
+export * from './selector-interpolated.js';
+export * from './default-guard.js';
+export * from './rest.js';
+export * from './url.js';
+//# sourceMappingURL=index.d.ts.map