@signal9/era-ui 32.0.0 → 33.0.0

package/dist/docs/css-utilities.js

@@ -1,317 +0,0 @@
-/*
- * Extracts era's Tailwind v4 `@utility` classes — era-link, era-text-trim,
- * era-shimmer, scrollbar-none, material-popover, … — from the stylesheet source.
- *
- * These are first-class API but they have no JS export and no .svelte file, so
- * nothing else in the doc pipeline can see them: the component barrel misses
- * them, the registry misses them, and a consumer (or an agent) reasoning from
- * "what does era expose for links?" never finds `era-link`. The doc comment
- * above each `@utility` is already thorough, so it — not a hand-maintained list
- * — is the source of truth. This parses it.
- *
- * The convention the parser leans on: an `@use ` line in the comment is the
- * one-line use case (what an agent searches), and the remaining prose is the
- * long description. A utility with no `@use` line still documents fine; it just
- * lands in the docs without a use-case summary.
- *
- * Pure (takes sources, returns data) so both the runtime glob loader and the
- * node build script can drive it — same split as component-source-scanners.ts.
- */
-/** Files whose utilities are library API. Order fixes the doc's order. */
-const FILE_ORDER = ['index.css'];
-/**
- * `@theme` namespace → the utility prefixes it generates.
- *
- * Half of era's public class API is registered this way rather than as
- * `@utility` blocks — `rounded-control` from `--radius-control`, `shadow-lg`,
- * `bg-highlight`, `text-body`, and the whole spacing scale. They are classes a
- * consumer writes exactly like the others, and until this table existed the
- * doc pipeline could not see any of them: `@utility` was the only thing it
- * parsed, so era's most-used names were also its least-documented.
- *
- * The list per namespace is the SPELLINGS WORTH DOCUMENTING, not everything
- * Tailwind derives — a spacing token really does generate `mt-`, `gap-x-`,
- * `inset-`, `translate-` and a dozen more, and printing all of them per name
- * would bury the point. The prose says the rest.
- */
-export const THEME_CLASS_PREFIXES = {
-    radius: ['rounded'],
-    shadow: ['shadow'],
-    text: ['text'],
-    leading: ['leading'],
-    ease: ['ease'],
-    color: ['bg', 'text', 'border'],
-    spacing: ['p', 'px', 'py', 'gap']
-};
-/** Every prefix a namespace really generates — the map the codemod needs. */
-export const THEME_ALL_PREFIXES = {
-    ...THEME_CLASS_PREFIXES,
-    radius: [
-        'rounded',
-        ...'t,r,b,l,tl,tr,bl,br,s,e,ss,se,es,ee'.split(',').map((s) => `rounded-${s}`)
-    ],
-    color: [
-        'bg',
-        'text',
-        'border',
-        'fill',
-        'stroke',
-        'ring',
-        'outline',
-        'divide',
-        'decoration',
-        'caret',
-        'accent',
-        'from',
-        'via',
-        'to'
-    ],
-    spacing: [
-        'p,px,py,pt,pr,pb,pl,ps,pe',
-        'm,mx,my,mt,mr,mb,ml,ms,me',
-        'gap,gap-x,gap-y',
-        'w,h,size,min-w,min-h,max-w,max-h',
-        'inset,inset-x,inset-y,top,right,bottom,left,start,end',
-        'translate,translate-x,translate-y,scroll-m,scroll-p,basis,indent'
-    ]
-        .join(',')
-        .split(',')
-};
-function cleanComment(raw) {
-    return raw
-        .split('\n')
-        .map((line) => line.replace(/^\s*\*\s?/, '').trimEnd())
-        .join('\n')
-        .trim();
-}
-/** Split the comment into its `@use` one-liner and the surrounding prose. */
-function splitUseCase(comment) {
-    const lines = comment.split('\n');
-    const start = lines.findIndex((line) => line.startsWith('@use '));
-    if (start === -1)
-        return { description: comment.trim() };
-    let end = start + 1;
-    while (end < lines.length && lines[end].trim() !== '')
-        end++;
-    const useCase = lines
-        .slice(start, end)
-        .join(' ')
-        .replace(/^@use\s+/, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-    const description = [...lines.slice(0, start), ...lines.slice(end)].join('\n').trim();
-    return { useCase, description };
-}
-/** Walk from the opening brace to its match so nested rules survive intact. */
-function blockEnd(source, openBrace) {
-    let depth = 0;
-    for (let i = openBrace; i < source.length; i++) {
-        if (source[i] === '{')
-            depth++;
-        else if (source[i] === '}' && --depth === 0)
-            return i;
-    }
-    return source.length - 1;
-}
-function parseFile(file, source) {
-    const out = [];
-    // The comment body may not contain a terminator — a lazy `[\s\S]*?` would
-    // happily start at the first comment in the file and run through every `*/`
-    // between there and the @utility.
-    const pattern = /\/\*((?:(?!\*\/)[\s\S])*)\*\/\s*@utility\s+([\w-]+)\s*\{/g;
-    for (const match of source.matchAll(pattern)) {
-        const names = [match[2]];
-        let end = blockEnd(source, match.index + match[0].length - 1);
-        // One doc comment may govern a RUN of consecutive @utility blocks — a
-        // ladder like h-icon…h-bar shares one story, and repeating it five times
-        // would drown the docs. Attach every block that follows the previous one
-        // with nothing but whitespace in between; the next commented block never
-        // matches here because the outer pattern requires the comment.
-        const next = /^\s*@utility\s+([\w-]+)\s*\{/;
-        for (let m; (m = next.exec(source.slice(end + 1)));) {
-            names.push(m[1]);
-            end = blockEnd(source, end + 1 + m[0].length - 1);
-        }
-        const { useCase, description } = splitUseCase(cleanComment(match[1]));
-        out.push({
-            name: names[0],
-            names,
-            file,
-            useCase,
-            description,
-            css: source.slice(source.indexOf('@utility', match.index), end + 1)
-        });
-    }
-    return out;
-}
-/**
- * The classes one `@theme` key generates, each with the utility PREFIX that
- * generated it — `--spacing-inset-control` → `{ prefix: 'px', name:
- * 'px-inset-control' }`. The prefix cannot be recovered from the name (both
- * `px` and `px-inset` are hyphen-splits of `px-inset-control`), and the codemod
- * matches on it, so it is returned rather than re-derived.
- */
-export function themeKeyClassEntries(themeKey, prefixes = THEME_CLASS_PREFIXES) {
-    const bare = themeKey.replace(/^--/, '');
-    // Tailwind's metadata sub-keys (`--text-title--line-height`) configure a
-    // scale entry; they are not classes of their own, and listing them as such
-    // put `text-title--letter-spacing` in the reference as if a consumer could
-    // write it.
-    if (bare.includes('--'))
-        return [];
-    // `--shadow: …` IS the bare `shadow` class — a namespace with no suffix.
-    if (prefixes[bare])
-        return [{ prefix: bare, name: bare }];
-    const cut = bare.indexOf('-');
-    if (cut === -1)
-        return [];
-    const namespace = bare.slice(0, cut);
-    const suffix = bare.slice(cut + 1);
-    return (prefixes[namespace] ?? []).map((p) => ({ prefix: p, name: `${p}-${suffix}` }));
-}
-/** The class names one `@theme` key generates, e.g. `--radius-control` → `rounded-control`. */
-export function themeKeyClasses(themeKey, prefixes = THEME_CLASS_PREFIXES) {
-    return themeKeyClassEntries(themeKey, prefixes).map((e) => e.name);
-}
-/**
- * Named theme scales — the other half of the public class API.
- *
- * Shape parsed: a doc comment followed by a RUN of `--key: var(…)` lines inside
- * `@theme`, exactly like the `@utility` ladder rule above. One comment governs
- * the whole run, so the radius ladder or the spacing scale documents once.
- */
-function parseTheme(file, source) {
-    // Anchored to the start of a line: `@theme` also appears in PROSE (the layering
-    // comment in index.css explains that @utility and @theme are Tailwind's to
-    // place), and an unanchored match happily started inside that comment, ran to
-    // the next `{` it found, and returned garbage — silently dropping every
-    // theme-derived class from the docs.
-    const theme = source.match(/^@theme[^{]*\{([\s\S]*?)\n\}/m);
-    if (!theme)
-        return [];
-    const body = theme[1];
-    const out = [];
-    const pattern = /\/\*((?:(?!\*\/)[\s\S])*)\*\/\s*((?:\s*--[\w-]+\s*:[^;]+;\n?)+)/g;
-    for (const match of body.matchAll(pattern)) {
-        const decls = [...match[2].matchAll(/--[\w-]+\s*:[^;]+;/g)].map((m) => m[0]);
-        const names = decls.flatMap((d) => themeKeyClasses(d.slice(0, d.indexOf(':')).trim()));
-        // A comment governing only non-class keys (--default-transition-*) has
-        // nothing to document — it is internal wiring, not API.
-        if (!names.length)
-            continue;
-        const { useCase, description } = splitUseCase(cleanComment(match[1]));
-        out.push({
-            name: names[0],
-            names,
-            file,
-            useCase,
-            description,
-            css: `@theme inline {\n${decls.map((d) => `\t${d}`).join('\n')}\n}`
-        });
-    }
-    return out;
-}
-/**
- * @param sources stylesheet text keyed by path relative to src/lib/styles
- *   (e.g. `index.css`, `surfaces/glass.css`).
- */
-export function parseUtilities(sources) {
-    const rank = (file) => {
-        const i = FILE_ORDER.indexOf(file);
-        return i === -1 ? FILE_ORDER.length : i;
-    };
-    return Object.entries(sources)
-        .sort(([a], [b]) => rank(a) - rank(b) || a.localeCompare(b))
-        .flatMap(([file, source]) => [...parseFile(file, source), ...parseTheme(file, source)]);
-}
-const INTRO = [
-    "era's styling API is pure class names — write `tier-control px-gutter shadow`,",
-    'never the `h-(--era-h-control)` var-class spelling. Everything below rides along',
-    'with the stylesheet and needs no import:',
-    '',
-    '```ts',
-    'import "@signal9/era-ui/css";',
-    '```',
-    '',
-    '```svelte',
-    '<button class="tier-control px-inset-control shadow text-body">era styled</button>',
-    '```',
-    '',
-    'Alongside the `@utility` classes referenced below, era registers named theme',
-    'scales that OVERLOAD the stock Tailwind names, so ordinary-looking markup',
-    'renders on-design and responds to every axis (density, surface, corners,',
-    'motion):',
-    '',
-    '| Stock-looking class | What it resolves to |',
-    '|---|---|',
-    '| `tier-icon/pill/chip/control/bar` | indivisible bounded height + concentric radius |',
-    '| `rounded-icon/pill/chip/control/bar` | the concentric radius ladder (collapses on `data-corners="square"`) |',
-    '| `rounded-menu-item` | menu-row radius, concentric inside a `rounded-control` panel |',
-    '| `shadow` / `shadow-lg` | resting control edge / floating panel chrome, per surface |',
-    '| `shadow-well` / `shadow-pressed` / `shadow-highlight` | recessed, pressed/latched, hover-material chrome |',
-    '| `bg-well` / `bg-elevated` / `bg-highlight` / `bg-overlay` | surface fills: resting, raised, transient feedback, modal scrim |',
-    '| `transition-*` (bare) | duration + easing default to the motion axis |',
-    '| `ease-base` / `duration-base` | the motion axis, named explicitly |',
-    '| `text-body` | density-derived body/control text size |',
-    '| `p-gutter` / `gap-gutter` / `mt-gutter` / … | the spacing scale — EVERY spacing prefix works |',
-    '',
-    'THE SPACING NAMES IN SIZE ORDER, smallest first, because the names do not',
-    'imply it and guessing gets it backwards:',
-    '',
-    '    gutter  <  panel  <  field  <  card  <  content',
-    '',
-    'Measured at `data-mode="balanced"`: gutter 5px, field ~9px, card ~11px,',
-    'content ~22px. `gutter` is the TIGHT one — the gap between sibling controls',
-    "and a rail's own padding. `field` is a text input's side padding, not the",
-    'label-to-input gap. Reading them the other way round produces a layout whose',
-    'hierarchy is inverted and therefore reads flat.',
-    '',
-    'The spacing names (`gutter`, `card`, `panel`, `content`, `menu`, `field`, the',
-    '`inset-*` and concentric `*-inset-*` insets, `glyph-*`) are registered as a',
-    'Tailwind spacing scale, so every prefix derives automatically: `p-`, `px-`,',
-    '`pt-`, `mt-`, `gap-`, `gap-x-`, `inset-`, `translate-`, and the rest. The TIER',
-    'names (`icon`, `pill`, `chip`, `control`, `bar`) are dimensions, not spacing, so',
-    'they are registered per prefix instead — `h-`, `w-`, `min-h-`, `min-w-` and',
-    '`size-` — and the two vocabularies deliberately share no word. Putting a tier',
-    'in the spacing scale would silently make `px-control` mean 24px of padding.',
-    'For chrome, use `tier-T`, which binds `h-T` and `rounded-T`; use the separate',
-    'dimension/radius names only for width, minimums, unbounded surfaces, or',
-    'asymmetric/docked corners.',
-    '',
-    'The var form (`h-(--era-h-control)`) still works and is the escape hatch for a',
-    'token with no registered name — `--era-sp`, the press-sink offsets, anything',
-    'a component reaches for once. `scripts/check-canonical.ts` fails the build if',
-    'source uses it where a name exists.'
-].join('\n');
-/**
- * `h-icon` for a single class, `h-icon · h-pill · … · h-bar` for a ladder.
- *
- * Capped, because a theme scale can govern a LOT of spellings: the colour block
- * generates bg-/text-/border- for every token, which is ~60 names and reads as
- * noise in a heading. The prose under each entry states the full rule.
- */
-const LABEL_CAP = 8;
-const label = (u) => u.names.length > LABEL_CAP
-    ? `${u.names.slice(0, LABEL_CAP).join(' · ')} · … (${u.names.length} in all)`
-    : u.names.join(' · ');
-/** Renders the utilities reference — the generated `utilities.md` body. */
-export function buildUtilitiesDoc(utilities) {
-    const lines = ['## Overview', '', INTRO, '', '| Utility | Use it for |', '|---|---|'];
-    for (const u of utilities) {
-        lines.push(`| ${u.names.map((n) => `\`${n}\``).join(' ')} | ${u.useCase ?? '—'} |`);
-    }
-    lines.push('');
-    for (const u of utilities) {
-        lines.push(`## ${label(u)}`, '');
-        if (u.useCase)
-            lines.push(`**Use it for:** ${u.useCase}`, '');
-        if (u.description)
-            lines.push(u.description, '');
-        lines.push(`Declared in \`${u.file}\`.`, '', '```css', u.css, '```', '');
-    }
-    return lines.join('\n');
-}
-/** One line per utility (or ladder) for llms.txt — plus its searchable use case. */
-export function buildUtilitiesIndex(utilities) {
-    return utilities.map((u) => `- \`${label(u)}\` — ${u.useCase ?? u.description.split('\n')[0]}`);
-}

package/dist/docs/extract-props.d.ts

@@ -1,13 +0,0 @@
-export interface PropSpec {
-    name: string;
-    type: string;
-    optional: boolean;
-    default?: string;
-    bindable?: boolean;
-    description?: string;
-}
-export interface ComponentSpec {
-    inherits: string[];
-    props: PropSpec[];
-}
-export declare function extractProps(source: string): ComponentSpec | null;

package/dist/docs/extract-props.js

@@ -1,324 +0,0 @@
-export function extractProps(source) {
-    const script = extractScript(source);
-    if (!script)
-        return null;
-    const propsIdx = script.indexOf('$props(');
-    if (propsIdx === -1)
-        return null;
-    // Walk backwards through balanced brackets to locate `let { … }: … = $props()`.
-    // We find the `=` directly preceding `$props(`, then the matching `:`, then
-    // the destructure's closing `}`. Both the `=` and `:` must be at bracket
-    // depth 0 so we skip past any `=`/`:` buried inside the destructure or
-    // generic type arguments.
-    const eqIdx = findPrevTopLevel(script, propsIdx - 1, '=');
-    if (eqIdx === -1)
-        return null;
-    const typeEnd = eqIdx;
-    const typeStart = findPrevTopLevel(script, typeEnd - 1, ':');
-    if (typeStart === -1)
-        return null;
-    const typeExpr = script.slice(typeStart + 1, typeEnd).trim();
-    // Before `:` should be the destructure's closing `}`.
-    let braceEnd = typeStart - 1;
-    while (braceEnd >= 0 && /\s/.test(script[braceEnd]))
-        braceEnd--;
-    if (script[braceEnd] !== '}')
-        return null;
-    const braceStart = findMatchingOpen(script, braceEnd);
-    if (braceStart === -1)
-        return null;
-    const destructure = script.slice(braceStart + 1, braceEnd);
-    const defaults = parseDestructure(destructure);
-    const { inherits, literal } = parseTypeExpr(typeExpr);
-    // Merge defaults onto literal members; anything declared as bindable in the
-    // destructure is marked here too.
-    for (const prop of literal) {
-        const d = defaults[prop.name];
-        if (!d)
-            continue;
-        if (d.default !== undefined)
-            prop.default = d.default;
-        if (d.bindable)
-            prop.bindable = true;
-    }
-    // If the destructure introduces bindables not visible in the literal (a
-    // forwarded prop like `value` on Slider.Root), surface them anyway so the
-    // doc notes binding support.
-    for (const [name, d] of Object.entries(defaults)) {
-        if (literal.find((p) => p.name === name))
-            continue;
-        if (!d.bindable)
-            continue;
-        literal.push({
-            name,
-            type: '(forwarded)',
-            optional: true,
-            default: d.default,
-            bindable: true
-        });
-    }
-    return { inherits, props: literal };
-}
-function extractScript(source) {
-    // A component may have both a `<script module>` (tv() variants, etc.) and
-    // the instance `<script>`. $props() lives in the instance block, so scan
-    // all blocks and prefer the one that actually contains $props(); fall back
-    // to the last non-module block. Reading only the first block silently
-    // missed props on module-first components (badge/chip/card/skeleton).
-    const blocks = [...source.matchAll(/<script([^>]*)>([\s\S]*?)<\/script>/g)];
-    if (blocks.length === 0)
-        return null;
-    const withProps = blocks.find((b) => b[2].includes('$props('));
-    if (withProps)
-        return withProps[2];
-    const instance = blocks.filter((b) => !/\bmodule\b/.test(b[1])).at(-1);
-    return (instance ?? blocks[0])[2];
-}
-// If `src[i]` starts a string, template literal, or comment, skip past it and
-// return the next index. Otherwise returns `i` unchanged so callers can decide
-// what to do with the character.
-function skipNonCode(src, i) {
-    const c = src[i];
-    // Arrow `=>` is neither a bracket nor an operator we track. Skipping it as a
-    // unit keeps the lone `>` from being counted as a generic-bracket close
-    // (which corrupted depth on arrow-typed props like `(d: E) => void`) and
-    // keeps its `=` from being mistaken for the `= $props()` assignment.
-    if (c === '=' && src[i + 1] === '>')
-        return i + 2;
-    if (c === '"' || c === "'") {
-        const quote = c;
-        i++;
-        while (i < src.length && src[i] !== quote) {
-            if (src[i] === '\\')
-                i++;
-            i++;
-        }
-        return i + 1;
-    }
-    if (c === '`') {
-        i++;
-        while (i < src.length && src[i] !== '`') {
-            if (src[i] === '\\')
-                i++;
-            else if (src[i] === '$' && src[i + 1] === '{') {
-                i = findMatchingClose(src, i + 1) + 1;
-                continue;
-            }
-            i++;
-        }
-        return i + 1;
-    }
-    if (c === '/' && src[i + 1] === '/') {
-        while (i < src.length && src[i] !== '\n')
-            i++;
-        return i;
-    }
-    if (c === '/' && src[i + 1] === '*') {
-        i += 2;
-        while (i < src.length - 1 && !(src[i] === '*' && src[i + 1] === '/'))
-            i++;
-        return i + 2;
-    }
-    return i;
-}
-function findMatchingClose(src, openIdx) {
-    const open = src[openIdx];
-    const close = { '{': '}', '(': ')', '[': ']', '<': '>' }[open];
-    if (!close)
-        return -1;
-    let depth = 0;
-    let i = openIdx;
-    while (i < src.length) {
-        const next = skipNonCode(src, i);
-        if (next !== i) {
-            i = next;
-            continue;
-        }
-        const c = src[i];
-        if (c === open)
-            depth++;
-        else if (c === close) {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-        i++;
-    }
-    return -1;
-}
-function findMatchingOpen(src, closeIdx) {
-    const close = src[closeIdx];
-    const open = { '}': '{', ')': '(', ']': '[', '>': '<' }[close];
-    if (!open)
-        return -1;
-    // Rescan forward tracking balance rather than scanning backwards — handling
-    // string/comment boundaries in reverse is error-prone.
-    const stack = [];
-    let i = 0;
-    while (i <= closeIdx) {
-        const next = skipNonCode(src, i);
-        if (next !== i) {
-            i = next;
-            continue;
-        }
-        const c = src[i];
-        if (c === open)
-            stack.push(i);
-        else if (c === close) {
-            const o = stack.pop();
-            if (i === closeIdx)
-                return o ?? -1;
-        }
-        i++;
-    }
-    return -1;
-}
-function findPrevTopLevel(src, end, token) {
-    // Records only matches at bracket depth 0, skipping nested expressions.
-    let found = -1;
-    let depth = 0;
-    let i = 0;
-    while (i <= end) {
-        const next = skipNonCode(src, i);
-        if (next !== i) {
-            i = next;
-            continue;
-        }
-        const c = src[i];
-        if (c === '{' || c === '(' || c === '[' || c === '<')
-            depth++;
-        else if (c === '}' || c === ')' || c === ']' || c === '>')
-            depth--;
-        else if (depth === 0 && c === token)
-            found = i;
-        i++;
-    }
-    return found;
-}
-function splitTopLevel(s, delim) {
-    const out = [];
-    let start = 0;
-    let depth = 0;
-    let i = 0;
-    while (i < s.length) {
-        const next = skipNonCode(s, i);
-        if (next !== i) {
-            i = next;
-            continue;
-        }
-        const c = s[i];
-        if (c === '{' || c === '(' || c === '[' || c === '<')
-            depth++;
-        else if (c === '}' || c === ')' || c === ']' || c === '>')
-            depth--;
-        else if (depth === 0 && c === delim) {
-            out.push(s.slice(start, i));
-            start = i + 1;
-        }
-        i++;
-    }
-    out.push(s.slice(start));
-    return out;
-}
-function parseTypeExpr(typeExpr) {
-    const branches = splitTopLevel(typeExpr, '&')
-        .map((b) => b.trim())
-        .filter(Boolean);
-    const inherits = [];
-    const literal = [];
-    for (const branch of branches) {
-        if (branch.startsWith('{')) {
-            const close = findMatchingClose(branch, 0);
-            if (close === -1)
-                continue;
-            literal.push(...parseLiteralMembers(branch.slice(1, close)));
-        }
-        else {
-            inherits.push(branch);
-        }
-    }
-    return { inherits, literal };
-}
-function parseLiteralMembers(body) {
-    const entries = splitTopLevel(body, ';')
-        .map((s) => s.trim())
-        .filter(Boolean);
-    const props = [];
-    for (const entry of entries) {
-        let description;
-        let remainder = entry;
-        const jsdoc = remainder.match(/^\/\*\*([\s\S]*?)\*\/\s*/);
-        if (jsdoc) {
-            description = jsdoc[1].replace(/^\s*\*\s?/gm, '').trim();
-            remainder = remainder.slice(jsdoc[0].length);
-        }
-        // Strip any remaining leading line comments.
-        while (remainder.startsWith('//')) {
-            const nl = remainder.indexOf('\n');
-            remainder = nl === -1 ? '' : remainder.slice(nl + 1).trimStart();
-        }
-        const m = remainder.match(/^([A-Za-z_$][\w$]*)(\??)\s*:\s*([\s\S]+)$/);
-        if (!m)
-            continue;
-        props.push({
-            name: m[1],
-            optional: m[2] === '?',
-            type: m[3].trim(),
-            description
-        });
-    }
-    return props;
-}
-function parseDestructure(body) {
-    const entries = splitTopLevel(body, ',')
-        .map((s) => s.trim())
-        .filter(Boolean);
-    const out = {};
-    for (const entry of entries) {
-        if (entry.startsWith('...'))
-            continue;
-        let left = entry;
-        let defaultVal;
-        const eq = findTopLevelChar(entry, '=');
-        if (eq !== -1) {
-            left = entry.slice(0, eq).trim();
-            defaultVal = entry.slice(eq + 1).trim();
-        }
-        // Strip alias: `class: className` → name is `class`.
-        const colon = findTopLevelChar(left, ':');
-        if (colon !== -1)
-            left = left.slice(0, colon).trim();
-        const bindable = /^\$bindable\b/.test(defaultVal ?? '');
-        let normalizedDefault = defaultVal;
-        if (bindable && defaultVal) {
-            // `$bindable(null)` → `null`; `$bindable<T>(x)` → `x`.
-            const paren = defaultVal.indexOf('(');
-            const close = paren === -1 ? -1 : findMatchingClose(defaultVal, paren);
-            if (paren !== -1 && close !== -1) {
-                normalizedDefault = defaultVal.slice(paren + 1, close).trim() || undefined;
-            }
-        }
-        out[left] = { default: normalizedDefault, bindable };
-    }
-    return out;
-}
-function findTopLevelChar(s, ch) {
-    let depth = 0;
-    let i = 0;
-    while (i < s.length) {
-        const next = skipNonCode(s, i);
-        if (next !== i) {
-            i = next;
-            continue;
-        }
-        const c = s[i];
-        if (c === '{' || c === '(' || c === '[' || c === '<')
-            depth++;
-        else if (c === '}' || c === ')' || c === ']' || c === '>')
-            depth--;
-        else if (depth === 0 && c === ch)
-            return i;
-        i++;
-    }
-    return -1;
-}

package/dist/docs/generated-docs.d.ts

@@ -1,6 +0,0 @@
-export declare const docsBySlug: Record<string, string>;
-export declare const knownSlugs: Set<string>;
-/** Served verbatim at /utilities.json so tooling can enumerate the CSS API. */
-export declare const utilitiesJson: string;
-export declare const llmsTxtTemplate: string;
-export declare const llmsFullTxt: string;

package/dist/docs/generated-docs.js

@@ -1,30 +0,0 @@
-const markdownFiles = import.meta.glob('../generated-docs/*.md', {
-    query: '?raw',
-    import: 'default',
-    eager: true
-});
-const textFiles = import.meta.glob('../generated-docs/*.txt', {
-    query: '?raw',
-    import: 'default',
-    eager: true
-});
-const manifestModules = import.meta.glob('../generated-docs/manifest.json', {
-    import: 'default',
-    eager: true
-});
-const utilitiesModules = import.meta.glob('../generated-docs/utilities.json', {
-    query: '?raw',
-    import: 'default',
-    eager: true
-});
-function stem(path) {
-    return path.replace(/^\.\.\/generated-docs\//, '').replace(/\.(md|txt)$/, '');
-}
-export const docsBySlug = Object.fromEntries(Object.entries(markdownFiles).map(([file, body]) => [stem(file), body]));
-const manifest = Object.values(manifestModules)[0];
-const manifestSlugs = manifest?.entries?.map((entry) => entry.slug) ?? [];
-export const knownSlugs = new Set(manifestSlugs.length ? manifestSlugs : Object.keys(docsBySlug));
-/** Served verbatim at /utilities.json so tooling can enumerate the CSS API. */
-export const utilitiesJson = utilitiesModules['../generated-docs/utilities.json'] ?? '';
-export const llmsTxtTemplate = textFiles['../generated-docs/llms.txt'] ?? '';
-export const llmsFullTxt = textFiles['../generated-docs/llms-full.txt'] ?? '';