@pre.style/core 3.0.0-alpha.0 → 3.1.0-alpha.1

package/dist/compiler/compiler.js

@@ -1,9 +1,12 @@
 import { readFileSync } from 'node:fs';
-import { resolve as resolvePath, sep } from 'node:path';
+import { dirname, relative, resolve as resolvePath, sep } from 'node:path';
+import { transform } from 'lightningcss';
 import SweatMap from 'sweatmap';
-import { parseBlock, PreStyleError, valueOf } from './block.js';
+import { dropOverridden, parseBlock, PreStyleError, valueOf } from './block.js';
 import { print } from './print.js';
 import { lvhfaRank, withClass } from './selectors.js';
+import { KEYFRAMES_PREFIX } from './keyframes.js';
+import { MARKER_PREFIX, markerKey, parseStylesheet } from './stylesheet.js';
 const RANGES = {
     Digits: { start: '0030', end: '0039' },
     Uppercase: { start: '0041', end: '005A' },
@@ -44,12 +47,22 @@ export class Compiler {
     // most deeply nested library first.
     #prepend;
     #libraries;
+    // The layer the output is wrapped in, as parsed, or null for none.
+    #layer;
     #blocks = new Map();
-    // One name list for every class, and one for prefixes (the at-rules and
-    // selector variant a class is under), which only the `cn` table uses.
+    #stylesheets = new Map();
+    #root;
+    // One name list for every class, one for prefixes (the at-rules and
+    // selector variant a class is under), which only the `cn` table uses, and
+    // one for localized keyframes.
     #names;
-    // How often each class and prefix is used across scanned blocks.
-    #counts = { atoms: new Map(), prefixes: new Map() };
+    // How often each class, prefix, and localized keyframes is used across
+    // scanned blocks.
+    #counts = {
+        atoms: new Map(),
+        prefixes: new Map(),
+        keyframes: new Map(),
+    };
     #atoms = new Map();
     #globals = new Map();
     // The current global for each overridable at-rule.
@@ -60,13 +73,23 @@ export class Compiler {
         this.#names = {
             atoms: new SweatMap(options.quirksMode ? QUIRKS_NAME_OPTIONS : NAME_OPTIONS),
             prefixes: new SweatMap(NAME_OPTIONS),
+            // Keyframes names are case-sensitive, even in quirks mode. They reach
+            // four characters only after about 227,000 names, so they're never
+            // `none` or a CSS-wide keyword.
+            keyframes: new SweatMap(NAME_OPTIONS),
         };
+        this.#layer = layerRule(options.layer);
         const root = options.root ?? process.cwd();
+        this.#root = root;
         this.#prepend = readPrepend(root, options.prependFiles);
         this.#libraries = (options.libraries ?? [])
             .map((library) => {
             const dir = resolvePath(root, library.dir);
-            return { dir: dir + sep, prepend: readPrepend(dir, library.prependFiles) };
+            return {
+                dir: dir + sep,
+                prepend: readPrepend(dir, library.prependFiles),
+                keyframeLocalization: library.keyframeLocalization ?? false,
+            };
         })
             .toSorted((a, b) => b.dir.length - a.dir.length);
         this.#parseOptions = {
@@ -84,18 +107,23 @@ export class Compiler {
     // block before `assignNames`.
     scan(block) {
         const parsed = this.#parse(block);
-        for (const atom of parsed.atoms) {
-            count(this.#counts.atoms, atomKey(atom));
-            const prefix = prefixKey(atom);
-            if (prefix !== '')
-                count(this.#counts.prefixes, prefix);
-        }
         this.#register(block, parsed);
+        this.#count(this.#resolveBlock(block, parsed, []));
+        for (const global of parsed.globals)
+            this.#countKeyframes(global.key);
+    }
+    // Pass 1 of naming for a stylesheet file: counts what each class uses.
+    scanStylesheet(sheet) {
+        const parsed = this.#parseSheet(sheet);
+        for (const name of parsed.classes.keys())
+            this.#count(this.#resolveClass(sheet.file, parsed, name, [], []));
+        for (const global of parsed.globals)
+            this.#countKeyframes(global.key);
     }
     // Pass 2 of naming: gives the most-used entries the shortest names. Ties
     // are broken by key, so names don't depend on the order files are read.
     assignNames() {
-        for (const list of ['atoms', 'prefixes']) {
+        for (const list of ['atoms', 'prefixes', 'keyframes']) {
             const sorted = [...this.#counts[list]].toSorted(([a, countA], [b, countB]) => countB - countA || (a < b ? -1 : a > b ? 1 : 0));
             for (const [key] of sorted)
                 this.#names[list].set(key);
@@ -106,7 +134,38 @@ export class Compiler {
     classString(block) {
         const parsed = this.#parse(block);
         this.#register(block, parsed);
-        return parsed.atoms.map((atom) => this.#nameOf(this.#atoms.get(atomKey(atom)))).join(' ');
+        return this.#classString(this.#resolveBlock(block, parsed, []));
+    }
+    // The files a block's class string depends on, through `composes … from`.
+    dependencies(block) {
+        const dependencies = [];
+        this.#resolveBlock(block, this.#parse(block), dependencies);
+        return [...new Set(dependencies)];
+    }
+    // The classes a stylesheet file exports, without compiling or keeping
+    // anything, for tools that only need the names (such as the TypeScript
+    // content mapper).
+    classNames(sheet) {
+        const { options } = this.#library(sheet.file);
+        try {
+            const parsed = parseStylesheet(sheet.code, sheet.lang, sheet.file, relative(this.#root, sheet.file), options);
+            return [...parsed.classes.keys()];
+        }
+        catch (error) {
+            throw error instanceof PreStyleError ? locate(error, fileBlock(sheet.file)) : error;
+        }
+    }
+    // Each class of a stylesheet file, with its class string.
+    stylesheet(sheet) {
+        const parsed = this.#parseSheet(sheet);
+        const dependencies = [...parsed.dependencies];
+        const exports = [];
+        for (const name of parsed.classes.keys())
+            exports.push([
+                name,
+                this.#classString(this.#resolveClass(sheet.file, parsed, name, [], dependencies)),
+            ]);
+        return { exports, dependencies: [...new Set(dependencies)] };
     }
     css() {
         const sources = [];
@@ -124,8 +183,25 @@ export class Compiler {
             .filter((g) => g.global.hoist !== false)
             .toSorted((a, b) => a.global.hoist - b.global.hoist);
         const rest = globals.filter((g) => g.global.hoist === false);
-        const rules = [...hoisted, ...rest].map((g) => withLoc(g.global.rule, loc(g.source)));
+        const named = (g) => withLoc(hasPlaceholder(g.global.key) ? this.#named(g.global.rule) : g.global.rule, loc(g.source));
+        let rules = [...hoisted, ...rest].map(named);
         rules.push(...this.#atomRules(loc));
+        // `@import` and `@namespace` can't be inside a layer, so they stay
+        // before it. `@layer` statements go inside, so the layers they order
+        // are the same ones blocks' `@layer` rules add to.
+        if (this.#layer !== null) {
+            rules = [
+                ...rules.filter(outside),
+                {
+                    type: 'layer-block',
+                    value: {
+                        ...valueOf(this.#layer),
+                        rules: rules.filter((r) => !outside(r)),
+                        loc: loc(null),
+                    },
+                },
+            ];
+        }
         return print(rules, sources, this.#parseOptions.lightningcss, this.#options.sourceMap ?? false);
     }
     // Classes on the element have an empty prefix.
@@ -141,17 +217,29 @@ export class Compiler {
         }
         return table;
     }
+    // A library's blocks and files get its prepended files and keyframes
+    // setting instead of the app's.
+    #library(file) {
+        const library = file === undefined ? -1 : this.#libraries.findIndex(({ dir }) => file.startsWith(dir));
+        const { prepend, keyframeLocalization } = library === -1
+            ? { prepend: this.#prepend, keyframeLocalization: this.#options.keyframeLocalization }
+            : this.#libraries[library];
+        return {
+            library,
+            options: {
+                ...this.#parseOptions,
+                prepend,
+                keyframeLocalization: keyframeLocalization ?? false,
+            },
+        };
+    }
     #parse(block) {
-        // A library's blocks get its prepended files instead of the app's.
-        const library = block.file === undefined
-            ? -1
-            : this.#libraries.findIndex(({ dir }) => block.file.startsWith(dir));
-        const prepend = library === -1 ? this.#prepend : this.#libraries[library].prepend;
+        const { library, options } = this.#library(block.file);
         const cacheKey = `${library}\n${block.lang}\n${block.code}`;
         let parsed = this.#blocks.get(cacheKey);
         if (parsed === undefined) {
             try {
-                parsed = parseBlock(block.code, block.lang, { ...this.#parseOptions, prepend });
+                parsed = parseBlock(block.code, block.lang, options);
             }
             catch (error) {
                 throw error instanceof PreStyleError ? locate(error, block) : error;
@@ -160,6 +248,146 @@ export class Compiler {
         }
         return parsed;
     }
+    // Parses a stylesheet file and registers its classes and global rules, so
+    // the output includes them once the file is used.
+    #parseSheet(sheet) {
+        const { library, options } = this.#library(sheet.file);
+        const cacheKey = `${library}\n${sheet.lang}\n${sheet.file}\n${sheet.code}`;
+        let parsed = this.#stylesheets.get(cacheKey);
+        if (parsed === undefined) {
+            try {
+                parsed = parseStylesheet(sheet.code, sheet.lang, sheet.file, relative(this.#root, sheet.file), options);
+            }
+            catch (error) {
+                throw error instanceof PreStyleError ? locate(error, fileBlock(sheet.file)) : error;
+            }
+            this.#stylesheets.set(cacheKey, parsed);
+        }
+        const block = fileBlock(sheet.file);
+        for (const target of parsed.classes.values())
+            this.#register(block, { atoms: target.atoms, globals: [], composes: [] });
+        this.#register(block, { atoms: [], globals: parsed.globals, composes: [] });
+        return parsed;
+    }
+    // Reads a file named by `composes … from`.
+    #readSheet(file) {
+        let code;
+        try {
+            code = readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            throw new PreStyleError(`Can't read ${file}, named by \`composes\`.`, null, { cause: error });
+        }
+        return this.#parseSheet({ code, lang: file.endsWith('.scss') ? 'scss' : 'css', file });
+    }
+    // A class's atoms and other names, after its `composes`. Composed atoms
+    // come first, so the class's own declarations replace the ones they
+    // conflict with, as in `cn`. `stack` holds the classes being resolved, to
+    // find cycles. Files composed from are added to `dependencies`.
+    #resolveClass(file, parsed, name, stack, dependencies) {
+        const target = parsed.classes.get(name);
+        if (target === undefined)
+            throw new PreStyleError(`${file} has no class \`${name}\` to compose.`, null);
+        const id = `${file}\0${name}`;
+        if (stack.includes(id))
+            throw new PreStyleError(`\`composes\` cycle: ${[...stack, id].map((entry) => entry.replace('\0', ' .')).join(' -> ')}.`, null);
+        const composed = this.#resolveComposes(file, parsed, target.composes, [...stack, id], dependencies);
+        if (target.marker)
+            composed.extras.push(markerKey(relative(this.#root, file), name));
+        return {
+            atoms: composed.atoms.length === 0
+                ? target.atoms
+                : dropOverridden([...composed.atoms, ...target.atoms]),
+            extras: composed.extras,
+        };
+    }
+    #resolveBlock(block, parsed, dependencies) {
+        if (parsed.composes.length === 0)
+            return { atoms: parsed.atoms, extras: [] };
+        for (const c of parsed.composes) {
+            if (c.from.type === 'local')
+                throw new PreStyleError('Blocks have no classes of their own to compose. Use `composes: a from "./file.css";` or `composes: a from global;`.', c.position);
+        }
+        const file = block.file ?? resolvePath(this.#root, 'block.css');
+        let composed;
+        try {
+            composed = this.#resolveComposes(file, null, parsed.composes, [], dependencies);
+        }
+        catch (error) {
+            throw error instanceof PreStyleError ? locate(error, block) : error;
+        }
+        return { atoms: dropOverridden([...composed.atoms, ...parsed.atoms]), extras: composed.extras };
+    }
+    #resolveComposes(file, parsed, composes, stack, dependencies) {
+        const atoms = [];
+        const extras = [];
+        for (const c of composes) {
+            if (c.from.type === 'global') {
+                extras.push(...c.names);
+                continue;
+            }
+            let from = file;
+            let sheet = parsed;
+            if (c.from.type === 'file') {
+                from = resolvePath(dirname(file), c.from.path);
+                dependencies.push(from);
+                sheet = this.#readSheet(from);
+                dependencies.push(...sheet.dependencies);
+            }
+            for (const name of c.names) {
+                const resolved = this.#resolveClass(from, sheet, name, stack, dependencies);
+                atoms.push(...resolved.atoms);
+                extras.push(...resolved.extras);
+            }
+        }
+        return { atoms, extras };
+    }
+    #count(resolved) {
+        for (const atom of resolved.atoms) {
+            count(this.#counts.atoms, atomKey(atom));
+            const prefix = prefixKey(atom);
+            if (prefix !== '')
+                count(this.#counts.prefixes, prefix);
+            this.#countKeyframes(atom.declaration.key);
+        }
+        for (const extra of resolved.extras)
+            if (extra.startsWith(MARKER_PREFIX))
+                count(this.#counts.atoms, extra);
+    }
+    #classString(resolved) {
+        const names = resolved.atoms.map((atom) => this.#nameOf(this.#atoms.get(atomKey(atom))));
+        for (const extra of resolved.extras)
+            names.push(extra.startsWith(MARKER_PREFIX) ? this.#names.atoms.set(extra) : extra);
+        return [...new Set(names)].join(' ');
+    }
+    // Counts the localized keyframes a JSON key names.
+    #countKeyframes(json) {
+        if (!json.includes(KEYFRAMES_KEY))
+            return;
+        for (const [, hash] of json.matchAll(KEYFRAMES_KEY_RE))
+            count(this.#counts.keyframes, KEYFRAMES_PREFIX + hash);
+    }
+    // Replaces markers in selectors, and localized keyframes names, with their
+    // names.
+    #named(value) {
+        const visit = (node) => {
+            if (Array.isArray(node))
+                return node.map(visit);
+            if (node === null || typeof node !== 'object')
+                return node;
+            const record = node;
+            if (record.type === 'class' &&
+                typeof record.name === 'string' &&
+                record.name.startsWith(MARKER_PREFIX))
+                return { ...record, name: this.#names.atoms.set(record.name) };
+            if (record.type === 'ident' &&
+                typeof record.value === 'string' &&
+                record.value.startsWith(KEYFRAMES_PREFIX))
+                return { ...record, value: this.#names.keyframes.set(record.value) };
+            return Object.fromEntries(Object.entries(record).map(([k, v]) => [k, visit(v)]));
+        };
+        return visit(value);
+    }
     #register(block, parsed) {
         for (const atom of parsed.atoms) {
             const key = atomKey(atom);
@@ -211,12 +439,17 @@ export class Compiler {
             const rules = sortAtoms(group.atoms).map((record) => {
                 const { atom, source } = record;
                 const className = this.#nameOf(record);
-                const selectors = atom.variant
+                let selectors = atom.variant
                     ? withClass(atom.variant.selectors, className)
                     : [[{ type: 'class', name: className }]];
+                if (atom.variant?.key.includes(MARKER_KEY))
+                    selectors = this.#named(selectors);
+                const value = atom.declaration.key.includes(KEYFRAMES_KEY)
+                    ? this.#named(atom.declaration.value)
+                    : atom.declaration.value;
                 const declarations = atom.declaration.important
-                    ? { importantDeclarations: [atom.declaration.value] }
-                    : { declarations: [atom.declaration.value] };
+                    ? { importantDeclarations: [value] }
+                    : { declarations: [value] };
                 return {
                     type: 'style',
                     value: { selectors, declarations, rules: [], loc: loc(source) },
@@ -233,6 +466,42 @@ export class Compiler {
         return emit(root);
     }
 }
+// Markers and localized keyframes names as they appear in JSON keys, which
+// escape the `\0`.
+const MARKER_KEY = JSON.stringify(MARKER_PREFIX).slice(1, -1);
+const KEYFRAMES_KEY = JSON.stringify(KEYFRAMES_PREFIX).slice(1, -1);
+const KEYFRAMES_KEY_RE = new RegExp(`${RegExp.escape(KEYFRAMES_KEY)}([\\w-]+)`, 'g');
+// Rules that can't be inside a layer.
+const outside = (rule) => rule.type === 'import' || rule.type === 'namespace';
+const hasPlaceholder = (json) => json.includes(MARKER_KEY) || json.includes(KEYFRAMES_KEY);
+// Parses the `layer` option into an `@layer` block rule.
+function layerRule(layer) {
+    if (layer === undefined || layer === false)
+        return null;
+    if (typeof layer !== 'string')
+        throw new PreStyleError('`layer` must be `false` or a string.', null);
+    let rule;
+    try {
+        transform({
+            filename: 'layer.css',
+            code: Buffer.from(`@layer ${layer} {}`),
+            visitor: {
+                StyleSheetExit(sheet) {
+                    if (sheet.rules.length === 1)
+                        rule = sheet.rules[0];
+                },
+            },
+        });
+    }
+    catch {
+        // Reported below.
+    }
+    if (rule?.type !== 'layer-block' || (layer.trim() === '') !== (rule.value.name == null))
+        throw new PreStyleError(`\`layer\` must be a layer name, such as "pre.style" or "base.components", or "" for an unnamed layer. Got ${JSON.stringify(layer)}.`, null);
+    return rule;
+}
+// A stylesheet file, for positions and source maps.
+const fileBlock = (file) => ({ code: '', lang: 'css', file, line: 1, column: 1 });
 // Reads prepended files, relative to `dir`, once.
 function readPrepend(dir, files) {
     const read = (list = []) => list.map((file) => readFileSync(resolvePath(dir, file), 'utf8')).join('\n');

package/dist/compiler/config.d.ts

@@ -0,0 +1,16 @@
+import type { PrependFiles } from './compiler.ts';
+import type { LibraryConfig } from './libraries.ts';
+export interface PackageConfig {
+    include?: string | string[];
+    exclude?: string | string[];
+    prependFiles?: PrependFiles;
+    libraries?: Record<string, LibraryConfig | boolean>;
+    quirksMode?: boolean;
+    keyframeLocalization?: boolean;
+}
+export declare function checkField(field: Record<string, unknown>, where: string, keys: Set<string>): string[];
+export declare function readConfig(root: string): {
+    dir: string;
+    config: PackageConfig;
+    warnings: string[];
+};

package/dist/compiler/config.js

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const KEYS = new Set([
+    'include',
+    'exclude',
+    'prependFiles',
+    'libraries',
+    'quirksMode',
+    'keyframeLocalization',
+]);
+const isStrings = (value) => typeof value === 'string' ||
+    (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+const isPrependFiles = (value) => (Array.isArray(value) && isStrings(value)) ||
+    (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.entries(value).every(([lang, files]) => (lang === 'css' || lang === 'scss') && Array.isArray(files) && isStrings(files)));
+// Checks a `pre.style` field's shared keys, and returns warnings for keys
+// it doesn't know. `where` names the field in errors.
+export function checkField(field, where, keys) {
+    const fail = (key, expected) => {
+        throw new Error(`[pre.style] ${where}: \`${key}\` must be ${expected}.`);
+    };
+    if (field.include !== undefined && !isStrings(field.include))
+        fail('include', 'a glob or an array of globs');
+    if (field.exclude !== undefined && !isStrings(field.exclude))
+        fail('exclude', 'a glob or an array of globs');
+    if (field.prependFiles !== undefined && !isPrependFiles(field.prependFiles))
+        fail('prependFiles', 'an array of paths, or an object with `css` and `scss` arrays');
+    if (field.quirksMode !== undefined && typeof field.quirksMode !== 'boolean')
+        fail('quirksMode', '`true` or `false`');
+    if (field.keyframeLocalization !== undefined && typeof field.keyframeLocalization !== 'boolean')
+        fail('keyframeLocalization', '`true` or `false`');
+    if (field.libraries !== undefined &&
+        (field.libraries === null ||
+            typeof field.libraries !== 'object' ||
+            Array.isArray(field.libraries)))
+        fail('libraries', 'an object of package names');
+    return Object.keys(field)
+        .filter((key) => !keys.has(key))
+        .map((key) => `${where}: unknown key \`${key}\`.`);
+}
+// Reads the `pre.style` field from the package.json nearest `root`. `dir`
+// is the package's directory, which the field's paths are relative to.
+export function readConfig(root) {
+    for (let dir = root;; dir = dirname(dir)) {
+        const file = join(dir, 'package.json');
+        if (existsSync(file)) {
+            const field = JSON.parse(readFileSync(file, 'utf8'))['pre.style'];
+            if (field === undefined)
+                return { dir, config: {}, warnings: [] };
+            const where = `"pre.style" in ${file}`;
+            if (field === null || typeof field !== 'object' || Array.isArray(field))
+                throw new Error(`[pre.style] ${where} must be an object.`);
+            const warnings = checkField(field, where, KEYS);
+            return { dir, config: field, warnings };
+        }
+        if (dirname(dir) === dir)
+            return { dir: root, config: {}, warnings: [] };
+    }
+}

package/dist/compiler/index.d.ts

@@ -1,5 +1,10 @@
 export { Compiler, createCompiler } from './compiler.ts';
-export type { Block, CompilerOptions, Library, PrependFiles } from './compiler.ts';
+export type { Block, CompiledStylesheet, CompilerOptions, Library, PrependFiles, Stylesheet, } from './compiler.ts';
 export { PreStyleError } from './block.ts';
 export type { Lang, LightningOptions, Position } from './block.ts';
 export type { Printed } from './print.ts';
+export { checkField, readConfig } from './config.ts';
+export type { PackageConfig } from './config.ts';
+export { findLibraries } from './libraries.ts';
+export type { LibraryConfig, ResolvedLibrary } from './libraries.ts';
+export { isIdentifier } from './stylesheet.ts';

package/dist/compiler/index.js

@@ -1,2 +1,5 @@
 export { Compiler, createCompiler } from './compiler.js';
 export { PreStyleError } from './block.js';
+export { checkField, readConfig } from './config.js';
+export { findLibraries } from './libraries.js';
+export { isIdentifier } from './stylesheet.js';

package/dist/compiler/keyframes.d.ts

@@ -0,0 +1,6 @@
+import type { Atom, GlobalRule } from './block.ts';
+export declare const KEYFRAMES_PREFIX = "\0pre.style-keyframes:";
+export declare function localizeKeyframes(globals: GlobalRule[]): {
+    globals: GlobalRule[];
+    atoms: (atoms: Atom[]) => Atom[];
+};

package/dist/compiler/keyframes.js

@@ -0,0 +1,120 @@
+import { createHash } from 'node:crypto';
+import { key, overrideKey, valueOf } from './block.js';
+// With `keyframeLocalization`, each `@keyframes` name is replaced with a
+// generated one, like styled-components' `keyframes`. In parsed rules, a
+// local name is an ident with this prefix and a hash of every definition of
+// the name in its scope (a block, or a stylesheet file), so identical
+// keyframes share a name wherever they're defined. The compiler gives it a
+// name when printing.
+export const KEYFRAMES_PREFIX = '\0pre.style-keyframes:';
+// Properties whose values name keyframes, without a vendor prefix.
+const ANIMATION_PROPERTIES = new Set(['animation', 'animation-name']);
+// Replaces each `@keyframes` name defined in a scope (in its globals, which
+// include its prepended code) with a local name, in the definitions, and,
+// through `atoms`, in `animation` and `animation-name` declarations. Names
+// the scope doesn't define are left as they are.
+export function localizeKeyframes(globals) {
+    const definitions = new Map();
+    for (const global of globals)
+        eachKeyframes(global.rule, (value) => {
+            const list = definitions.get(value.name.value) ?? [];
+            list.push(key({ vendorPrefix: value.vendorPrefix, keyframes: value.keyframes }));
+            definitions.set(value.name.value, list);
+        });
+    if (definitions.size === 0)
+        return { globals, atoms: (atoms) => atoms };
+    const local = new Map();
+    for (const [name, list] of definitions)
+        local.set(name, KEYFRAMES_PREFIX +
+            createHash('sha256').update(JSON.stringify(list)).digest('base64url').slice(0, 16));
+    return {
+        globals: globals.map((global) => {
+            let found = false;
+            const rule = mapRule(global.rule, (inner) => {
+                if (inner.type !== 'keyframes')
+                    return inner;
+                found = true;
+                const value = valueOf(inner);
+                return {
+                    ...inner,
+                    value: {
+                        ...value,
+                        name: { type: 'ident', value: local.get(value.name.value) },
+                    },
+                };
+            });
+            if (!found)
+                return global;
+            return {
+                ...global,
+                key: key(rule),
+                rule,
+                overrideKey: global.overrideKey === null ? null : overrideKey(rule),
+            };
+        }),
+        atoms: (atoms) => atoms.map((atom) => {
+            if (!ANIMATION_PROPERTIES.has(atom.property.replace(/^-\w+-/, '')))
+                return atom;
+            const value = renameIdents(atom.declaration.value, local);
+            if (value === atom.declaration.value)
+                return atom;
+            return {
+                ...atom,
+                declaration: {
+                    ...atom.declaration,
+                    key: key(value) + (atom.declaration.important ? '!' : ''),
+                    value,
+                },
+            };
+        }),
+    };
+}
+// Calls `visit` for each `@keyframes` rule in a rule, including inside the
+// at-rules a global keeps around it.
+function eachKeyframes(rule, visit) {
+    mapRule(rule, (inner) => {
+        if (inner.type === 'keyframes')
+            visit(valueOf(inner));
+        return inner;
+    });
+}
+// Maps a rule and the rules nested in it.
+function mapRule(rule, map) {
+    const value = valueOf(rule);
+    const mapped = Array.isArray(value.rules)
+        ? {
+            ...rule,
+            value: {
+                ...value,
+                rules: value.rules.map((r) => mapRule(r, map)),
+            },
+        }
+        : rule;
+    return map(mapped);
+}
+// Replaces names in idents and strings (parsed animation names, and tokens
+// in unparsed values). Returns `value` itself when nothing changed.
+function renameIdents(value, local) {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            const mapped = node.map(visit);
+            return mapped.some((item, i) => item !== node[i]) ? mapped : node;
+        }
+        if (node === null || typeof node !== 'object')
+            return node;
+        const record = node;
+        if ((record.type === 'ident' || record.type === 'string') &&
+            typeof record.value === 'string' &&
+            local.has(record.value))
+            return { type: 'ident', value: local.get(record.value) };
+        let changed = false;
+        const entries = Object.entries(record).map(([k, v]) => {
+            const mapped = visit(v);
+            if (mapped !== v)
+                changed = true;
+            return [k, mapped];
+        });
+        return changed ? Object.fromEntries(entries) : node;
+    };
+    return visit(value);
+}

package/dist/compiler/libraries.d.ts

@@ -0,0 +1,16 @@
+import type { PrependFiles } from './compiler.ts';
+export interface LibraryConfig {
+    include?: string | string[];
+    exclude?: string | string[];
+    prependFiles?: PrependFiles;
+    keyframeLocalization?: boolean;
+}
+export interface ResolvedLibrary {
+    name: string;
+    dir: string;
+    include: string[];
+    exclude: string[];
+    prependFiles?: PrependFiles;
+    keyframeLocalization?: boolean;
+}
+export declare function findLibraries(root: string, overrides?: Record<string, LibraryConfig | boolean>, warn?: (message: string) => void): ResolvedLibrary[];