@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/compiler-storybook/emit.js

@@ -0,0 +1,202 @@
+import { excerpt, lineOf } from "../compiler-core/index.js";
+export const CAPABILITIES = ["group.*", "story.*", "doc.*"];
+/** Writes one story file: its meta (a `story-group`) and each story. */
+export function emitCsf(builder, csf, index, indexPath) {
+    const at = (node, method = "ast") => builder.evidence({
+        sourceRef: `${csf.file}#${lineOf(node)}`,
+        location: { type: "file", path: csf.file, line: lineOf(node) },
+        method,
+        original: excerpt(node)
+    });
+    let groupRef;
+    if (csf.group) {
+        groupRef = builder.entity(`storybook:${csf.file}`, "story-group", csf.group.title ?? csf.file);
+        emitGroup(builder, groupRef, csf, csf.group, at);
+        if (index && indexPath) {
+            const entries = index.filter((e) => e.importPath.replace(/^\.\//, "") === indexPath);
+            const evidence = builder.evidence({
+                sourceRef: "storybook-static/index.json",
+                location: { type: "file", path: "storybook-static/index.json" },
+                method: "structured-parse"
+            });
+            builder.fact(groupRef, "group.index.entries", entries.map((e) => ({
+                id: e.id,
+                type: e.type,
+                ...(e.title ? { title: e.title } : {}),
+                ...(e.name ? { name: e.name } : {})
+            })), evidence);
+        }
+    }
+    for (const story of csf.stories)
+        emitStory(builder, csf, story, groupRef, at);
+}
+function emitGroup(builder, ref, csf, group, at) {
+    const node = at(group.node);
+    const put = (path, value, evidence = node, origin = "extracted", completeness) => builder.fact(ref, path, value, evidence, { origin, ...(completeness ? { completeness } : {}) });
+    put("group.file", csf.file);
+    if (group.title)
+        put("group.title", group.title);
+    else
+        put("group.titleAuto", true);
+    if (csf.selectionUncertain)
+        put("group.selectionUncertain", true);
+    if (csf.excluded.length > 0)
+        put("group.excludedExports", csf.excluded);
+    if (group.component) {
+        const ev = at(group.componentNode ?? group.node, "compiler-api");
+        const c = group.component;
+        put("group.component", {
+            text: c.text,
+            via: c.via,
+            ...(c.file ? { file: c.file } : {}),
+            ...(c.name ? { name: c.name } : {}),
+            ...(c.external ? { external: c.external } : {}),
+            ...(c.unresolvedModule ? { unresolvedModule: c.unresolvedModule } : {})
+        }, ev);
+    }
+    emitAnnotations(builder, ref, "group", group, at);
+}
+function emitStory(builder, csf, story, groupRef, at) {
+    const ref = builder.entity(`storybook:${csf.file}#${story.exportName}`, "story", story.name ?? story.exportName);
+    const node = at(story.node);
+    const put = (path, value, evidence = node, origin = "extracted") => builder.fact(ref, path, value, evidence, { origin });
+    put("story.exportName", story.exportName);
+    put("story.file", csf.file);
+    put("story.shape", story.shape);
+    if (story.name)
+        put("story.name", story.name);
+    if (groupRef)
+        put("story.group", groupRef);
+    if (story.description)
+        put("story.description", story.description, node, "authored");
+    put("story.hasRender", story.hasRender);
+    if (story.play) {
+        put("story.play.present", true);
+        if (story.play.calls.length > 0)
+            put("story.play.calls", story.play.calls);
+        if (story.play.steps.length > 0)
+            put("story.play.steps", story.play.steps);
+    }
+    if (story.composes.length > 0)
+        put("story.composes", story.composes, at(story.node, "compiler-api"));
+    emitAnnotations(builder, ref, "story", story, at);
+}
+function emitAnnotations(builder, ref, prefix, a, at) {
+    const put = (path, value, evidence, options = {}) => builder.fact(ref, `${prefix}.${path}`, value, evidence, {
+        origin: options.origin ?? "extracted",
+        ...(options.completeness ? { completeness: options.completeness } : {})
+    });
+    if (a.args.value && typeof a.args.value === "object" && !Array.isArray(a.args.value)) {
+        for (const [name, value] of Object.entries(a.args.value)) {
+            const node = a.argNodes.get(name) ?? a.argsNode;
+            if (node)
+                put(`args.${name}`, value, at(node));
+        }
+    }
+    if (a.args.unresolved.length > 0 && a.argsNode)
+        put("argsUnresolved", [...new Set(a.args.unresolved)].sort(), at(a.argsNode), { completeness: "partial" });
+    if (a.args.spies.length > 0 && a.argsNode)
+        put("argsSpies", [...new Set(a.args.spies)].sort(), at(a.argsNode));
+    for (const [prop, info] of Object.entries(a.argTypes)) {
+        const node = a.argTypeNodes.get(prop);
+        if (node)
+            emitArgType(put, `argTypes.${prop}`, info, at(node));
+    }
+    const firstArgType = [...a.argTypeNodes.values()][0];
+    if (a.argTypesUnresolved.length > 0 && firstArgType)
+        put("argTypesUnresolved", [...new Set(a.argTypesUnresolved)].sort(), at(firstArgType), {
+            completeness: "partial"
+        });
+    const p = a.parameters;
+    if (a.nodes.parameters && p.keys.length > 0) {
+        const ev = at(a.nodes.parameters);
+        put("parameters.keys", p.keys, ev);
+        if (p.a11y !== undefined)
+            put("parameters.a11y", p.a11y, ev);
+        if (p.layout)
+            put("parameters.layout", p.layout, ev);
+        if (p.controls !== undefined)
+            put("parameters.controls", p.controls, ev);
+        if (p.docsDescription?.component)
+            put("docs.description", p.docsDescription.component, ev, { origin: "authored" });
+    }
+    if (a.nodes.tags && a.tags && a.tags.length > 0)
+        put("tags", a.tags, at(a.nodes.tags));
+    if (a.nodes.decorators)
+        put("hasDecorators", true, at(a.nodes.decorators));
+    if (a.nodes.loaders)
+        put("hasLoaders", true, at(a.nodes.loaders));
+}
+function emitArgType(put, base, info, ev) {
+    put(`${base}.declared`, true, ev);
+    if (info.control !== undefined)
+        put(`${base}.control`, info.control, ev);
+    if (info.options)
+        put(`${base}.options`, info.options, ev, {
+            completeness: info.optionsUnresolved ? "partial" : "complete"
+        });
+    else if (info.optionsUnresolved)
+        put(`${base}.optionsUnresolved`, true, ev, { completeness: "partial" });
+    // A description is prose a person wrote in the story file.
+    if (info.description)
+        put(`${base}.description`, info.description, ev, { origin: "authored" });
+    if (info.defaultSummary !== undefined)
+        put(`${base}.defaultSummary`, info.defaultSummary, ev);
+    if (info.mappingKeys)
+        put(`${base}.mappingKeys`, info.mappingKeys, ev);
+    if (info.action)
+        put(`${base}.action`, info.action, ev);
+    if (info.hidden)
+        put(`${base}.hidden`, true, ev);
+    if (info.category)
+        put(`${base}.category`, info.category, ev);
+}
+/** Writes an MDX documentation page. Prose is authored; imports and blocks are extracted. */
+export function emitMdx(builder, doc) {
+    const ref = builder.entity(`storybook:${doc.path}`, "doc-page", doc.title ?? doc.path);
+    const structure = builder.evidence({
+        sourceRef: doc.path,
+        location: { type: "file", path: doc.path, line: 1 },
+        method: "document-parse"
+    });
+    const putStructure = (path, value, evidence = structure) => builder.fact(ref, path, value, evidence, { origin: "extracted" });
+    putStructure("doc.kind", "storybook-mdx");
+    putStructure("doc.file", doc.path);
+    if (doc.title)
+        builder.fact(ref, "doc.title", doc.title, structure, { origin: "authored" });
+    if (doc.metaTitle)
+        builder.fact(ref, "doc.meta.title", doc.metaTitle, structure, { origin: "authored" });
+    if (doc.metaOf) {
+        const ev = builder.evidence({
+            sourceRef: `${doc.path}#meta`,
+            location: { type: "file", path: doc.path, line: doc.metaOf.line },
+            method: "document-parse"
+        });
+        putStructure("doc.meta.of", { identifier: doc.metaOf.identifier, ...(doc.metaOf.file ? { file: doc.metaOf.file } : {}) }, ev);
+    }
+    if (doc.blocks.length > 0)
+        putStructure("doc.blocks", doc.blocks);
+    if (doc.storyRefs.length > 0) {
+        const first = doc.storyRefs[0];
+        const ev = builder.evidence({
+            sourceRef: `${doc.path}#stories`,
+            location: { type: "file", path: doc.path, line: first?.line ?? 1 },
+            method: "document-parse"
+        });
+        putStructure("doc.stories", doc.storyRefs.map(({ block, exportName, file }) => ({
+            block,
+            exportName,
+            ...(file ? { file } : {})
+        })), ev);
+    }
+    for (const [i, section] of doc.sections.entries()) {
+        const ev = builder.evidence({
+            sourceRef: `${doc.path}#${section.line}`,
+            location: { type: "file", path: doc.path, line: section.line },
+            method: "document-parse",
+            original: section.heading
+        });
+        builder.fact(ref, `doc.sections.s${i + 1}`, { heading: section.heading, level: section.level, text: section.text }, ev, { origin: "authored" });
+    }
+}
+//# sourceMappingURL=emit.js.map

package/dist/compiler-storybook/index-json.js

@@ -0,0 +1,41 @@
+/**
+ * Reads a built Storybook's `index.json`. Its format is not documented as public API, so parsing is
+ * tolerant (`entries` or the older `stories`) and uses only the fields below. It is optional evidence
+ * about which story files a build contained, never a source of story identity.
+ */
+export function parseBuiltIndex(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return undefined;
+    const record = parsed;
+    const format = record.entries !== undefined ? "entries" : record.stories !== undefined ? "stories" : undefined;
+    const raw = format === "entries" ? record.entries : record.stories;
+    if (!format || typeof raw !== "object" || raw === null)
+        return undefined;
+    const values = Array.isArray(raw) ? raw : Object.values(raw);
+    const entries = [];
+    for (const value of values) {
+        if (typeof value !== "object" || value === null)
+            continue;
+        const e = value;
+        const importPath = typeof e.importPath === "string" ? e.importPath : undefined;
+        if (!importPath || typeof e.id !== "string")
+            continue;
+        entries.push({
+            id: e.id,
+            type: typeof e.type === "string" ? e.type : "story",
+            ...(typeof e.title === "string" ? { title: e.title } : {}),
+            ...(typeof e.name === "string" ? { name: e.name } : {}),
+            importPath,
+            tags: Array.isArray(e.tags) ? e.tags.filter((t) => typeof t === "string") : []
+        });
+    }
+    return { entries: entries.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), format };
+}
+//# sourceMappingURL=index-json.js.map

package/dist/compiler-storybook/index.js

@@ -0,0 +1,5 @@
+export { ADAPTER_ID, ADAPTER_VERSION, storybookAdapter } from "./adapter.js";
+export { extractCsf } from "./csf.js";
+export { parseBuiltIndex } from "./index-json.js";
+export { parseMdx } from "./mdx.js";
+//# sourceMappingURL=index.js.map

package/dist/compiler-storybook/mdx.js

@@ -0,0 +1,120 @@
+import { posix } from "../compiler-core/index.js";
+const BLOCKS = new Set([
+    "Meta",
+    "Canvas",
+    "Story",
+    "Controls",
+    "ArgTypes",
+    "Source",
+    "Primary",
+    "Stories",
+    "Description",
+    "Subtitle",
+    "Title",
+    "Markdown",
+    "Unstyled",
+    "ColorPalette",
+    "IconGallery",
+    "Typeset"
+]);
+const MAX_SECTION_TEXT = 500;
+/**
+ * Reads a Storybook MDX page with line-based scanning. It does not compile or evaluate MDX: it records
+ * the imports, the doc blocks used and what they reference, and the prose outline.
+ */
+export function parseMdx(path, text, projectFiles) {
+    const lines = text.split("\n");
+    const imports = readImports(path, text, projectFiles);
+    const doc = { path, storyRefs: [], blocks: [], sections: [] };
+    const blocks = new Set();
+    let fence;
+    let current;
+    lines.forEach((raw, index) => {
+        const line = index + 1;
+        const fenceMatch = /^\s*(```+|~~~+)/.exec(raw);
+        if (fenceMatch) {
+            const marker = fenceMatch[1].slice(0, 3);
+            fence = fence === undefined ? marker : fence === marker ? undefined : fence;
+            return;
+        }
+        if (fence !== undefined)
+            return;
+        for (const match of raw.matchAll(/<([A-Z][A-Za-z]*)\b([^>]*?)\/?>/g)) {
+            const block = match[1];
+            if (!BLOCKS.has(block))
+                continue;
+            blocks.add(block);
+            const attributes = match[2];
+            const of = /\bof=\{\s*([A-Za-z_$][\w$]*)(?:\.([A-Za-z_$][\w$]*))?\s*\}/.exec(attributes);
+            if (block === "Meta") {
+                const title = /\btitle=(?:"([^"]*)"|'([^']*)')/.exec(attributes);
+                if (title)
+                    doc.metaTitle = (title[1] ?? title[2]);
+                if (of) {
+                    const imported = imports.get(of[1]);
+                    doc.metaOf = {
+                        identifier: of[1],
+                        ...(imported?.file ? { file: imported.file } : {}),
+                        line
+                    };
+                }
+            }
+            else if (of?.[2]) {
+                const imported = imports.get(of[1]);
+                doc.storyRefs.push({
+                    block,
+                    exportName: of[2],
+                    ...(imported?.file ? { file: imported.file } : {}),
+                    line
+                });
+            }
+        }
+        if (/^\s*(?:import|export)\s/.test(raw) || /^\s*<[A-Za-z]/.test(raw))
+            return;
+        const heading = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(raw);
+        if (heading) {
+            current = { heading: heading[2], level: heading[1].length, line, text: "" };
+            doc.sections.push(current);
+            return;
+        }
+        if (current && raw.trim() && current.text.length < MAX_SECTION_TEXT) {
+            current.text = `${current.text}${current.text ? " " : ""}${raw.trim()}`.slice(0, MAX_SECTION_TEXT);
+        }
+    });
+    doc.blocks = [...blocks].sort();
+    const title = doc.metaTitle ?? doc.sections.find((s) => s.level === 1)?.heading;
+    if (title)
+        doc.title = title;
+    return doc;
+}
+function readImports(path, text, projectFiles) {
+    const out = new Map();
+    const resolve = (spec) => {
+        if (!spec.startsWith("."))
+            return undefined;
+        const base = posix.normalize(posix.join(posix.dirname(path), spec));
+        const stripped = base.replace(/\.[cm]?[jt]sx?$/, "");
+        return [
+            base,
+            ...[".stories.tsx", ".stories.ts", ".stories.jsx", ".stories.js", ".tsx", ".ts", ".jsx", ".js"].map((e) => stripped + e),
+            ...[".tsx", ".ts", ".jsx", ".js"].map((e) => `${base}${e}`)
+        ].find((c) => projectFiles.has(c));
+    };
+    for (const match of text.matchAll(/import\s+([^;]+?)\s+from\s+["']([^"']+)["']/g)) {
+        const clause = match[1];
+        const file = resolve(match[2]);
+        const namespace = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause);
+        if (namespace)
+            out.set(namespace[1], { ...(file ? { file } : {}) });
+        const def = /^([A-Za-z_$][\w$]*)\s*(?:,|$)/.exec(clause);
+        if (def)
+            out.set(def[1], { ...(file ? { file } : {}) });
+        for (const named of /\{([^}]*)\}/.exec(clause)?.[1]?.split(",") ?? []) {
+            const alias = /(?:[\w$]+\s+as\s+)?([\w$]+)\s*$/.exec(named.trim());
+            if (alias?.[1])
+                out.set(alias[1], { ...(file ? { file } : {}) });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=mdx.js.map

package/dist/compiler-tokens/adapter.js

@@ -0,0 +1,158 @@
+import { hashText, IrBuilder, scanCssCustomProperties } from "../compiler-core/index.js";
+import { hashJson } from "../shared/index.js";
+import { classifyScope, valueKind } from "./css.js";
+import { parseJsonWithLines } from "./json-lines.js";
+import { extractJsonTokens } from "./json-tokens.js";
+export const ADAPTER_ID = "design-tokens";
+export const ADAPTER_VERSION = "0.1.0";
+/**
+ * Extracts design tokens from CSS custom properties and from W3C-Design-Tokens-shaped or Style
+ * Dictionary-shaped JSON. It records names, raw values, references and theme modes exactly as written.
+ * It does not decide token categories or semantic names: those are interpretation, not extraction.
+ */
+export const designTokensAdapter = {
+    id: ADAPTER_ID,
+    version: ADAPTER_VERSION,
+    type: "tokens",
+    async discover({ project }) {
+        const groups = new Map();
+        for (const file of project.tokenFiles) {
+            if (!isExtractable(file))
+                continue;
+            groups.set(file.package ?? "", [...(groups.get(file.package ?? "") ?? []), file]);
+        }
+        const used = new Set();
+        const sources = [];
+        for (const [packageId, files] of [...groups].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+            const pkg = project.packages.find((p) => p.id === packageId);
+            const slug = (pkg?.name ?? pkg?.dir ?? "root")
+                .toLowerCase()
+                .replace(/[^a-z0-9._-]+/g, "-")
+                .replace(/^[^a-z0-9]+|[-.]+$/g, "") || "root";
+            let id = `design-tokens-${slug}`;
+            for (let n = 2; used.has(id); n++)
+                id = `design-tokens-${slug}-${n}`;
+            used.add(id);
+            sources.push({
+                id,
+                type: "tokens",
+                location: pkg?.dir ?? ".",
+                config: { files: files.map((f) => f.path) },
+                inputHash: hashJson(files.map((f) => [f.path, f.contentHash]))
+            });
+        }
+        return { sources, diagnostics: [] };
+    },
+    async extract({ fs, project, source, clock }, config) {
+        const builder = new IrBuilder({
+            source: {
+                id: source.id,
+                type: source.type,
+                location: source.location,
+                inputHash: source.inputHash,
+                adapter: { name: ADAPTER_ID, version: ADAPTER_VERSION }
+            },
+            extractor: { name: ADAPTER_ID, version: ADAPTER_VERSION },
+            capabilities: ["name", "description", "deprecated", "value.*", "modes.*", "extensions.*"],
+            clock
+        });
+        let partial = false;
+        for (const file of project.tokenFiles.filter((f) => config.files.includes(f.path))) {
+            if (file.kind === "css-custom-properties") {
+                partial = (await extractCss({ fs, builder, file })) || partial;
+            }
+            else {
+                partial = (await extractJson({ fs, builder, file })) || partial;
+            }
+        }
+        return { ir: builder.build(partial ? "partial" : "complete") };
+    },
+    async validate({ ir }) {
+        return ir.entities.length === 0
+            ? [
+                {
+                    code: "tokens.none-extracted",
+                    severity: "warning",
+                    message: `No tokens were extracted for ${ir.source.id}`,
+                    sourceId: ir.source.id
+                }
+            ]
+            : [];
+    }
+};
+function isExtractable(file) {
+    return (file.kind === "css-custom-properties" ||
+        (file.kind === "json-tokens" && (file.format === "dtcg-like" || file.format === "style-dictionary-like")));
+}
+async function extractCss(input) {
+    const { fs, builder, file } = input;
+    const text = await fs.readFile(file.path);
+    if (hashText(text) !== file.contentHash)
+        throw new Error(`${file.path} changed after discovery`);
+    for (const variable of scanCssCustomProperties(text)) {
+        const scope = classifyScope(variable.chain);
+        const name = variable.name.slice(2);
+        const ref = scope.kind === "other"
+            ? `css:${file.path}#${variable.name}@${variable.scope}`
+            : `css:${file.path}#${variable.name}`;
+        builder.entity(ref, "token", name);
+        const evidence = builder.evidence({
+            sourceRef: `${file.path}#${variable.name}`,
+            location: { type: "file", path: file.path, line: variable.line },
+            method: "structured-parse",
+            original: `${variable.name}: ${variable.value};`
+        });
+        builder.fact(ref, "name", name, evidence);
+        builder.fact(ref, "extensions.css.name", variable.name, evidence);
+        // Per-scope facts live under the scope they describe, so a root and a dark definition never
+        // contradict each other; only two definitions in the same scope can conflict.
+        const base = scope.kind === "theme"
+            ? `extensions.css.modes.${scope.mode}`
+            : scope.kind === "root"
+                ? "extensions.css.root"
+                : "extensions.css";
+        builder.fact(ref, `${base}.rawValue`, variable.value, evidence);
+        builder.fact(ref, `${base}.valueKind`, valueKind(variable.value), evidence);
+        if (scope.kind === "other") {
+            builder.fact(ref, "extensions.css.scopeKind", "other", evidence);
+            builder.fact(ref, "extensions.css.scope", variable.scope, evidence);
+            continue;
+        }
+        if (scope.kind === "theme")
+            builder.fact(ref, `${base}.via`, scope.via, evidence);
+        const prefix = scope.kind === "theme" ? `modes.${scope.mode}` : "value";
+        if (variable.aliasOf)
+            builder.fact(ref, `${prefix}.aliasOf`, variable.aliasOf.slice(2), evidence);
+        else
+            builder.fact(ref, `${prefix}.value`, variable.value, evidence);
+    }
+    return file.cssVariablesTruncated === true;
+}
+async function extractJson(input) {
+    const { fs, builder, file } = input;
+    const text = await fs.readFile(file.path);
+    if (hashText(text) !== file.contentHash)
+        throw new Error(`${file.path} changed after discovery`);
+    for (const token of extractJsonTokens(parseJsonWithLines(text))) {
+        const ref = `token:${file.path}#${token.name}`;
+        builder.entity(ref, "token", token.name);
+        const evidence = builder.evidence({
+            sourceRef: `${file.path}#${token.name}`,
+            location: { type: "file", path: file.path, line: token.line },
+            method: "structured-parse"
+        });
+        builder.fact(ref, "name", token.name, evidence);
+        if (token.aliasOf)
+            builder.fact(ref, "value.aliasOf", token.aliasOf, evidence);
+        else
+            builder.fact(ref, "value.value", token.value, evidence);
+        if (token.type)
+            builder.fact(ref, `extensions.${token.format}.type`, token.type, evidence);
+        if (token.description)
+            builder.fact(ref, "description", token.description, evidence, { origin: "authored" });
+        if (token.deprecated)
+            builder.fact(ref, "deprecated", token.deprecated, evidence, { origin: "authored" });
+    }
+    return false;
+}
+//# sourceMappingURL=adapter.js.map

package/dist/compiler-tokens/css.js

@@ -0,0 +1,59 @@
+const ROOT = /^(?::root|html|:host|body)$/;
+const THEME_ATTR = /^(?:html|:root|body)?\[data-(?:theme|mode|color-scheme|color-mode)(?:[~^$*|]?=)?["']?([\w-]+)["']?\]$/;
+const THEME_CLASS = /^(?:html|:root|body)?\.(dark|light)$/;
+const THEME_PREFIX_CLASS = /^(?:html|:root|body)?\.theme-([\w-]+)$/;
+const MEDIA_SCHEME = /^@media\b.*prefers-color-scheme\s*:\s*(dark|light)\b/i;
+/**
+ * Classifies the rule chain around a custom property. Only well-known theme conventions are treated as
+ * themes: a data-theme-style attribute, `.dark`/`.light`/`.theme-*` classes, and
+ * `@media (prefers-color-scheme)` around a root selector. Any other selector is `other`, which usually
+ * means a component-private variable, and is never presented as a theme or default value.
+ */
+export function classifyScope(chain) {
+    const selector = [...chain].reverse().find((entry) => !entry.startsWith("@"));
+    if (selector === undefined)
+        return { kind: "other" };
+    const media = chain
+        .map((entry) => MEDIA_SCHEME.exec(entry)?.[1]?.toLowerCase())
+        .find((m) => m !== undefined);
+    const parts = selector.split(",").map((p) => p.trim());
+    const classified = parts.map((part) => {
+        if (ROOT.test(part))
+            return media ? { kind: "theme", mode: media, via: "media" } : { kind: "root" };
+        const match = THEME_ATTR.exec(part) ?? THEME_CLASS.exec(part) ?? THEME_PREFIX_CLASS.exec(part);
+        if (match?.[1])
+            return { kind: "theme", mode: match[1].toLowerCase(), via: "selector" };
+        return { kind: "other" };
+    });
+    const first = classified[0];
+    if (!first)
+        return { kind: "other" };
+    const same = classified.every((c) => c.kind === first.kind && (c.kind !== "theme" || (first.kind === "theme" && c.mode === first.mode)));
+    return same ? first : { kind: "other" };
+}
+const COLOR_FN = /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix)\(/i;
+const LENGTH = /^-?(?:\d+\.?\d*|\.\d+)(?:px|rem|em|%|vh|vw|vmin|vmax|ch|ex|pt|cm|mm|in)$/i;
+const TIME = /^-?(?:\d+\.?\d*|\.\d+)(?:ms|s)$/i;
+const NUMBER = /^-?(?:\d+\.?\d*|\.\d+)$/;
+/** Syntactic classification of a raw value. It says what the text looks like, nothing about design intent. */
+export function valueKind(raw) {
+    const value = raw.trim();
+    if (/^var\(/i.test(value))
+        return "reference";
+    if (/^#[0-9a-f]{3,8}$/i.test(value) || COLOR_FN.test(value))
+        return "color";
+    if (LENGTH.test(value))
+        return "length";
+    if (TIME.test(value))
+        return "time";
+    if (NUMBER.test(value))
+        return "number";
+    if (/^(?:calc|min|max|clamp)\(/i.test(value))
+        return "expression";
+    if (/^url\(/i.test(value))
+        return "url";
+    if (/^["']/.test(value))
+        return "string";
+    return "other";
+}
+//# sourceMappingURL=css.js.map

package/dist/compiler-tokens/index.js

@@ -0,0 +1,5 @@
+export { ADAPTER_ID, ADAPTER_VERSION, designTokensAdapter } from "./adapter.js";
+export { classifyScope, valueKind } from "./css.js";
+export { parseJsonWithLines } from "./json-lines.js";
+export { extractJsonTokens } from "./json-tokens.js";
+//# sourceMappingURL=index.js.map