@vectoriox/iox-ui 5.19.0 → 5.20.0

package/fesm2022/vectoriox-iox-ui-design-core.mjs

@@ -10452,16 +10452,38 @@ function deriveAccentTokens(seed, against, pack = {}) {
  */
 /** Family name → Google Fonts css2 `family=` id. Replaces the engine's private GOOGLE_FONTS map. */
 const FONT_CATALOG = SPEC_FONTS;
+/**
+ * Why iox-cms refused a font upload. The server answers `{ code }` beside its message; the admin
+ * translates the code (`filebox.fontUpload.<code>`), so the author reads why in their language.
+ */
+var FontUploadError;
+(function (FontUploadError) {
+    FontUploadError["NotAFont"] = "not_a_font";
+    FontUploadError["Empty"] = "empty";
+    FontUploadError["Unreadable"] = "unreadable";
+    FontUploadError["TooLarge"] = "too_large";
+})(FontUploadError || (FontUploadError = {}));
+/**
+ * The largest font FILE a studio may upload: 10 MB. A full static or variable Latin/Hebrew/Arabic
+ * family is well under it (Inter's variable TTF is 0.9 MB); an unsubsetted CJK family is not, and
+ * must be subset first. iox-cms stops reading the request at this size; the admin checks it before
+ * sending.
+ */
+const MAX_FONT_FILE_BYTES = 10 * 1024 * 1024;
 /** The token roles whose values name the families a page renders in. */
 const FONT_FAMILY_TOKENS = ['font-display', 'font-body', 'font-label', 'font-mono'];
 const DEFAULT_WEIGHT = 400;
 const MIN_WEIGHT = 100;
 const MAX_WEIGHT = 900;
+/** The bounds CSS gives `font-weight`; a variable font's axis may reach them (Roboto Flex: 100–1000). */
+const CSS_MIN_WEIGHT = 1;
+const CSS_MAX_WEIGHT = 1000;
 const FONT_FORMATS = ['woff2', 'woff', 'truetype', 'opentype'];
 /**
  * A CSS string literal, single-quoted: `\` and `'` escaped, line breaks and NUL dropped, and `<` /
  * `>` hex-escaped (`\3c `) — the face CSS is inlined into a `<style>` by the SSR engine, where an
- * uploaded family named `</style><script>` would otherwise close the element.
+ * uploaded family named `</style><script>` would otherwise close the element. `parseFontFamilies` is
+ * its exact inverse (escapes included), which is what keeps a family's name one value everywhere.
  */
 function cssString(value) {
     const body = String(value)
@@ -10472,6 +10494,175 @@ function cssString(value) {
         .replace(/>/g, '\\3e ');
     return `'${body}'`;
 }
+/** ONE family as a `font-family` entry — always quoted, so a family named `Acme, Serif` or `serif` is
+ *  that family, never a list or a generic. */
+function formatFontFamily(family) {
+    return cssString(String(family ?? '').trim());
+}
+/** Families → a `font-family` stack, each quoted (`formatFontFamily`); `parseFontFamilies` reverses it. */
+function formatFontFamilies(families) {
+    return (families ?? []).filter(f => String(f ?? '').trim() !== '').map(formatFontFamily).join(', ');
+}
+const HEX = /[0-9a-f]/i;
+const CSS_WS = /[ \t\n\r\f]/;
+const REPLACEMENT = '\uFFFD';
+/** A CSS escape at `s[at] === '\\'` → [the character it stands for, the index after it] (CSS Syntax §4.3.7). */
+function readEscape(s, at, inString) {
+    let i = at + 1;
+    if (i >= s.length)
+        return ['', i];
+    if (inString && /[\n\r\f]/.test(s[i]))
+        return ['', s[i] === '\r' && s[i + 1] === '\n' ? i + 2 : i + 1];
+    if (HEX.test(s[i])) {
+        let hex = '';
+        while (i < s.length && hex.length < 6 && HEX.test(s[i]))
+            hex += s[i++];
+        if (s[i] === '\r' && s[i + 1] === '\n')
+            i += 2;
+        else if (i < s.length && CSS_WS.test(s[i]))
+            i++;
+        const cp = parseInt(hex, 16);
+        const valid = cp > 0 && cp <= 0x10ffff && !(cp >= 0xd800 && cp <= 0xdfff);
+        return [valid ? String.fromCodePoint(cp) : REPLACEMENT, i];
+    }
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    return [ch, i + ch.length];
+}
+/** A stack's entries, each as the family it names and the exact text that named it. */
+function splitFontStack(stack) {
+    const s = String(stack ?? '');
+    const out = [];
+    let i = 0;
+    while (i < s.length) {
+        while (i < s.length && CSS_WS.test(s[i]))
+            i++;
+        if (i >= s.length)
+            break;
+        const start = i;
+        let family = '';
+        const quote = s[i];
+        if (quote === '"' || quote === "'") {
+            i++;
+            while (i < s.length && s[i] !== quote) {
+                if (s[i] === '\\') {
+                    const [ch, next] = readEscape(s, i, true);
+                    family += ch;
+                    i = next;
+                }
+                else
+                    family += s[i++];
+            }
+            i++;
+            while (i < s.length && s[i] !== ',')
+                i++;
+        }
+        else {
+            const words = [];
+            let word = '';
+            while (i < s.length && s[i] !== ',') {
+                if (s[i] === '\\') {
+                    const [ch, next] = readEscape(s, i, false);
+                    word += ch;
+                    i = next;
+                }
+                else if (CSS_WS.test(s[i])) {
+                    if (word)
+                        words.push(word);
+                    word = '';
+                    i++;
+                }
+                else
+                    word += s[i++];
+            }
+            if (word)
+                words.push(word);
+            family = words.join(' ');
+        }
+        const raw = s.slice(start, Math.min(i, s.length)).trim();
+        if (family.trim() !== '')
+            out.push({ family, raw });
+        if (s[i] === ',')
+            i++;
+    }
+    return out;
+}
+/** The entries of `stack` that do NOT name `family`, as written — what a fallback list keeps. */
+function fontStackWithout(stack, family) {
+    const key = fontFamilyKey(family);
+    return splitFontStack(stack).filter(e => fontFamilyKey(e.family) !== key).map(e => e.raw).join(', ');
+}
+const WEIGHT_NUMBER = /^\d+(?:\.\d+)?$/;
+const WEIGHT_RANGE = /^(\d+(?:\.\d+)?)(?:\s*[-\u2013\u2014]\s*|\s+)(\d+(?:\.\d+)?)$/;
+const clampWeight = (n, lo, hi) => Math.min(hi, Math.max(lo, Math.round(n)));
+/**
+ * Anything a file, a descriptor or an author may hold as a weight → its range, or null when it is
+ * not one: `700`, `'700'`, `'100 900'`, `'100-900'`, `'100–900'` (the tile's own spelling). A static
+ * weight clamps to 100–900 (as before); range ends clamp to CSS's 1–1000.
+ */
+function parseFontWeight(value) {
+    const text = typeof value === 'number' ? String(value) : typeof value === 'string' ? value.trim() : '';
+    if (WEIGHT_NUMBER.test(text)) {
+        const n = Number(text);
+        if (!(n > 0))
+            return null;
+        const w = clampWeight(n, MIN_WEIGHT, MAX_WEIGHT);
+        return { min: w, max: w };
+    }
+    const m = WEIGHT_RANGE.exec(text);
+    if (!m)
+        return null;
+    const a = clampWeight(Number(m[1]), CSS_MIN_WEIGHT, CSS_MAX_WEIGHT);
+    const b = clampWeight(Number(m[2]), CSS_MIN_WEIGHT, CSS_MAX_WEIGHT);
+    if (!(a > 0) || !(b > 0))
+        return null;
+    return a === b ? { min: a, max: a } : { min: Math.min(a, b), max: Math.max(a, b) };
+}
+/** A range in the stored / descriptor / CSS form: a number for one weight, `'<min> <max>'` for a span. */
+function fontWeightValue(range) {
+    return range.min === range.max ? range.min : `${range.min} ${range.max}`;
+}
+/** Any weight → the stored form; a bad value → 400 (as `normalizeFontWeight`). */
+function normalizeFontWeightValue(value) {
+    return fontWeightValue(parseFontWeight(value) ?? { min: DEFAULT_WEIGHT, max: DEFAULT_WEIGHT });
+}
+/** Any weight → its range; a bad value → 400–400. */
+function fontWeightRange(value) {
+    return parseFontWeight(value) ?? { min: DEFAULT_WEIGHT, max: DEFAULT_WEIGHT };
+}
+/** True when the weight spans more than one value (a variable font's wght axis). */
+function isFontWeightRange(value) {
+    const r = parseFontWeight(value);
+    return !!r && r.min !== r.max;
+}
+/** How a weight reads on screen: `700`, or `100–900` for a range. */
+function formatFontWeight(value) {
+    const r = fontWeightRange(value);
+    return r.min === r.max ? String(r.min) : `${r.min}\u2013${r.max}`;
+}
+/**
+ * A weight an author or a client SENT, held to what a face can be — or null: a whole number 100–900,
+ * or a range of whole numbers 1 ≤ min < max ≤ 1000. Nothing is clamped or rounded here; a value that
+ * would need it is refused (the PUT correction's rule).
+ */
+function checkFontWeight(value) {
+    const text = typeof value === 'number' ? String(value) : typeof value === 'string' ? value.trim() : '';
+    if (/^\d+$/.test(text)) {
+        const n = Number(text);
+        return n >= MIN_WEIGHT && n <= MAX_WEIGHT ? n : null;
+    }
+    const m = /^(\d+)(?:\s*[-\u2013\u2014]\s*|\s+)(\d+)$/.exec(text);
+    if (!m)
+        return null;
+    const min = Number(m[1]);
+    const max = Number(m[2]);
+    return min >= CSS_MIN_WEIGHT && max <= CSS_MAX_WEIGHT && min < max ? `${min} ${max}` : null;
+}
+/** True when a face of `weight` renders `wanted` from its own file (inside its range). */
+function fontWeightCovers(weight, wanted) {
+    const r = fontWeightRange(weight);
+    return wanted >= r.min && wanted <= r.max;
+}
 /** The file extensions a studio may upload as a font, and the descriptor format each one IS (§5b). */
 const FONT_FILE_FORMATS = Object.freeze({
     woff2: 'woff2', woff: 'woff', ttf: 'truetype', otf: 'opentype',
@@ -10500,7 +10691,8 @@ function fontFormatOf(fileNameOrKey) {
 function fontFileStem(key) {
     return fontFileName(key).replace(/\.[^.]+$/, '');
 }
-/** A weight as CSS can use it: 100–900, a bad value → 400. */
+/** A single weight as CSS can use it: 100–900, a bad value → 400. A range is not a single weight —
+ *  use `normalizeFontWeightValue` for a face. */
 function normalizeFontWeight(w) {
     const n = Math.round(Number(w));
     return Number.isFinite(n) && n > 0 ? Math.min(MAX_WEIGHT, Math.max(MIN_WEIGHT, n)) : DEFAULT_WEIGHT;
@@ -10526,7 +10718,7 @@ function buildFontFaceCss(descriptors) {
     const faces = new Map();
     for (const d of (descriptors ?? []).filter(usableDescriptor)) {
         const family = d.family.trim();
-        const weight = normalizeFontWeight(d.weight);
+        const weight = normalizeFontWeightValue(d.weight);
         const style = normalizeFontStyle(d.style);
         const id = `${fontFamilyKey(family)}|${weight}|${style}`;
         const face = faces.get(id) ?? { family, weight, style, files: [] };
@@ -10541,7 +10733,7 @@ function buildFontFaceCss(descriptors) {
             .join(', ');
         return [
             '@font-face {',
-            `  font-family: ${cssString(face.family)};`,
+            `  font-family: ${formatFontFamily(face.family)};`,
             `  src: ${src};`,
             `  font-weight: ${face.weight};`,
             `  font-style: ${face.style};`,
@@ -10551,6 +10743,18 @@ function buildFontFaceCss(descriptors) {
     })
         .join('\n');
 }
+/** Lighter first: by the range's lower end, then its upper end (a static 100 before a 100–900 file). */
+function compareFontWeights(a, b) {
+    const ra = fontWeightRange(a);
+    const rb = fontWeightRange(b);
+    return ra.min - rb.min || ra.max - rb.max;
+}
+/** The weight a family's preview renders at: 400 when a face covers it, else its lightest. */
+function previewFontWeight(weights) {
+    if (!weights?.length || weights.some(w => fontWeightCovers(w, DEFAULT_WEIGHT)))
+        return DEFAULT_WEIGHT;
+    return fontWeightRange([...weights].sort(compareFontWeights)[0]).min;
+}
 /** Files → families (§5b "Group into families"): the Files tile, the typeface dropdown and Design ▸ Type. */
 function groupFontFamilies(descriptors) {
     const groups = new Map();
@@ -10562,23 +10766,30 @@ function groupFontFamilies(descriptors) {
     }
     return [...groups.values()]
         .map(g => {
-        const faces = [...g.faces].sort((a, b) => normalizeFontWeight(a.weight) - normalizeFontWeight(b.weight)
+        const faces = [...g.faces].sort((a, b) => compareFontWeights(a.weight, b.weight)
             || normalizeFontStyle(a.style).localeCompare(normalizeFontStyle(b.style)));
+        const weights = new Map();
+        for (const f of faces) {
+            const w = normalizeFontWeightValue(f.weight);
+            weights.set(String(w), w);
+        }
         return {
             family: g.family,
-            weights: [...new Set(faces.map(f => normalizeFontWeight(f.weight)))].sort((a, b) => a - b),
+            weights: [...weights.values()].sort(compareFontWeights),
             styles: FONT_STYLES.filter(s => faces.some(f => normalizeFontStyle(f.style) === s)),
             faces,
         };
     })
         .sort((a, b) => a.family.localeCompare(b.family));
 }
-/** The family names in a CSS `font-family` stack, unquoted, in order. */
+/**
+ * The family names in a CSS `font-family` stack, in order — the exact inverse of `formatFontFamily` /
+ * `formatFontFamilies`: quotes removed, CSS escapes decoded (`\'`, `\\`, `\3c `), a comma INSIDE
+ * quotes kept, an unquoted name's words joined by one space. Every reader of a font token goes
+ * through this; a naive split on `,` is how `O'Neil Sans` stopped matching its own token.
+ */
 function parseFontFamilies(stack) {
-    return String(stack ?? '')
-        .split(',')
-        .map(f => f.trim().replace(/^(['"])(.*)\1$/, '$2').trim())
-        .filter(Boolean);
+    return splitFontStack(stack).map(e => e.family);
 }
 /** Where Google serves the stylesheets, and the origin the font FILES come from (preconnect). */
 const GOOGLE_FONTS_CSS_ORIGIN = 'https://fonts.googleapis.com';
@@ -10609,12 +10820,13 @@ function fontsForTokens(tokens, opts = {}) {
     const ids = [];
     for (const role of roles) {
         const row = rows.find(t => t.name === role);
-        for (const family of parseFontFamilies(row?.value ?? '')) {
-            const id = catalogFontId(family);
-            if (id && !seen.has(id)) {
-                seen.add(id);
-                ids.push(id);
-            }
+        // The role's FIRST catalog family is the one that renders (or stands in for an uploaded
+        // family that is missing — `userFontStack` puts the look's font right after the author's);
+        // a catalog family further down is never reached, so it is never loaded.
+        const id = parseFontFamilies(row?.value ?? '').map(catalogFontId).find((x) => !!x);
+        if (id && !seen.has(id)) {
+            seen.add(id);
+            ids.push(id);
         }
     }
     return ids;
@@ -10625,26 +10837,37 @@ function stackNamesFamily(stack, family) {
     return key !== '' && parseFontFamilies(stack ?? '').some(f => fontFamilyKey(f) === key);
 }
 /**
- * The font tokens whose value names `family` — what the delete guard asks before an uploaded family's
- * last file goes (§5b): deleting it would silently drop those roles to their fallback.
+ * The font tokens that render in `family` — their stack LEADS with it — what the delete guard asks
+ * before an uploaded family's last file goes (§5b): deleting it would drop those roles to their
+ * fallback. A role naming it further down (the look's font behind the author's, `userFontStack`) does
+ * not render in it, and rewriting that role would throw the author's own choice away.
  */
 function fontRoleReferences(tokens, family) {
+    const key = fontFamilyKey(family);
+    if (!key)
+        return [];
     const rows = (tokens ?? []).filter(t => !!t && typeof t.name === 'string');
-    return FONT_FAMILY_TOKENS.filter(role => rows.some(t => t.name === role && stackNamesFamily(t.value, family)));
+    return FONT_FAMILY_TOKENS.filter(role => rows.some(t => t.name === role
+        && fontFamilyKey(parseFontFamilies(t.value ?? '')[0]) === key));
 }
 /**
- * The face CSS font matching picks for `weight` from `faces` (CSS Fonts §5.2): 400 tries 500 next,
- * 500 tries 400; lighter weights look down first, heavier ones up. So an `h1` at 600 over a family
- * uploaded at 400 + 700 renders the real 700 cut — the one worth preloading.
+ * The face CSS font matching picks for `weight` from `faces` (CSS Fonts §5.2): a face whose range
+ * holds the weight is exact (a variable file covers every weight on its axis); otherwise 400 tries
+ * 500 next, 500 tries 400; lighter weights look down first, heavier ones up — each face measured at
+ * its nearest end. So an `h1` at 600 over a family uploaded at 400 + 700 renders the real 700 cut —
+ * the one worth preloading.
  */
 function matchFontWeight(faces, weight) {
     if (!faces?.length)
         return null;
     const want = normalizeFontWeight(weight);
-    const exact = faces.find(f => normalizeFontWeight(f.weight) === want);
+    const exact = faces.find(f => fontWeightCovers(f.weight, want));
     if (exact)
         return exact;
-    const w = (f) => normalizeFontWeight(f.weight);
+    const w = (f) => {
+        const r = fontWeightRange(f.weight);
+        return r.max < want ? r.max : r.min;
+    };
     const below = (max) => [...faces].filter(f => w(f) < max).sort((a, b) => w(b) - w(a))[0] ?? null;
     const above = (min) => [...faces].filter(f => w(f) > min).sort((a, b) => w(a) - w(b))[0] ?? null;
     if (want >= 400 && want <= 500) {
@@ -10683,6 +10906,35 @@ function fontPreloads(descriptors, tokens) {
     }
     return [...out.values()];
 }
+/** CSS generic families and the faces every visitor's system already has — never "missing". */
+const ALWAYS_AVAILABLE_FAMILIES = new Set([
+    'serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui', 'ui-serif', 'ui-sans-serif',
+    'ui-monospace', 'ui-rounded', 'emoji', 'math', 'fangsong', '-apple-system', 'blinkmacsystemfont',
+    'arial', 'helvetica', 'helvetica neue', 'georgia', 'times new roman', 'times', 'courier new', 'courier',
+    'verdana', 'tahoma', 'trebuchet ms', 'segoe ui', 'roboto', 'menlo', 'monaco', 'consolas',
+]);
+/**
+ * Board 8's "the same check runs when a font token points at a missing family": the font roles whose
+ * FIRST family is not uploaded (`uploaded` — the org's families), not in the catalog and not a system
+ * face. Only meaningful over a listing that SUCCEEDED — an empty bucket because storage is down would
+ * otherwise report every uploaded family missing.
+ */
+function missingFontRoles(tokens, uploaded) {
+    const have = new Set((uploaded ?? []).map(fontFamilyKey));
+    const available = (family) => {
+        const key = fontFamilyKey(family);
+        return have.has(key) || ALWAYS_AVAILABLE_FAMILIES.has(key) || catalogFontId(family) !== null;
+    };
+    const resolved = resolveTokenValues(tokens);
+    const out = [];
+    for (const role of FONT_FAMILY_TOKENS) {
+        const families = parseFontFamilies(resolved[role] ?? '');
+        if (!families.length || /^var\(/i.test(families[0]) || available(families[0]))
+            continue;
+        out.push({ role, family: families[0], fallback: families.slice(1).find(available) ?? '' });
+    }
+    return out;
+}
 
 /**
  * A flavor's COMPLETE token set for a studio's choices (design-system plan §3a/§3e). A flavor IS
@@ -10710,9 +10962,16 @@ function defaultDesignChoices(pack) {
         ...pack.defaults,
     };
 }
-/** `'<Family>', system-ui, sans-serif` — the value a font role holds once the author picks a face. */
-function userFontStack(family) {
-    return `${cssString(family.trim())}, ${USER_FONT_FALLBACK}`;
+/**
+ * The value a font role holds once the author picks a face: `'<Family>', <the look's own stack>` —
+ * e.g. `'Rubik', 'Inter Tight', system-ui, -apple-system, 'Segoe UI', sans-serif`. The look's font
+ * follows the author's, so a family that later stops existing (deleted outside the delete guard, a
+ * bucket emptied by hand) renders in the pack's font — Board 8's promise — in every renderer, with no
+ * runtime check. With no look stack: `system-ui, sans-serif`.
+ */
+function userFontStack(family, packStack) {
+    const fallback = fontStackWithout(packStack, family) || USER_FONT_FALLBACK;
+    return `${formatFontFamily(family)}, ${fallback}`;
 }
 const toRow = (t, source) => ({
     name: t.name,
@@ -10750,7 +11009,7 @@ function buildFlavorTokens(pack, choices) {
     set(BUTTON_RADIUS, choices.pillButtons ? PILL_RADIUS : (buttonRadius?.overridden ? buttonRadius.value : CONTROL_RADIUS));
     for (const [role, family] of Object.entries(choices.fonts ?? {})) {
         if (typeof family === 'string' && family.trim() !== '')
-            set(role, userFontStack(family), USER_TOKEN_SOURCE);
+            set(role, userFontStack(family, byName.get(role)?.value), USER_TOKEN_SOURCE);
     }
     if (choices.seed && choices.seed.toLowerCase() !== pack.seed.toLowerCase()) {
         const bg = byName.get('bg');
@@ -11255,5 +11514,5 @@ function planFontFamilyRemoval(existing, previous, family) {
  * Generated bundle index. Do not edit.
  */
 
-export { ACCENT_TOKEN_NAMES, BUTTON_VARIANT_TO_STYLE, COLOR_SCHEMES, COLOR_SCHEME_TRAIT, COLOR_SCHEME_TYPES, ColorScheme, DEFAULT_FLAVOR_ID, DESIGN_TOKEN_GROUPS, DESIGN_TOKEN_TIERS, DESIGN_TOKEN_TYPES, DesignConfigKey, ELEMENT_STYLES, ELEMENT_STYLE_MARKER_CLASS, ELEMENT_STYLE_STATES, EMPTY_IMAGE_ATTRIBUTE, EMPTY_IMAGE_SRC, ElementStyleState, FLAVOR_SPEC_VERSION, FONT_CATALOG, FONT_FAMILY_TOKENS, FONT_FILE_ACCEPT, FONT_FILE_EXTENSIONS, FONT_FILE_FORMATS, FONT_STYLES, FONT_WEIGHTS, GOOGLE_FONTS_CSS_ORIGIN, GOOGLE_FONTS_FILE_ORIGIN, OwnedTraitLink, PALETTE_PRESETS, REDUCED_MOTION_OVERRIDES, REDUCED_TRANSPARENCY_OVERRIDES, REVERT_WINDOW_MS, SPEC_A11Y, SPEC_AXES, SPEC_BUTTON_VARIANT_TO_STYLE, SPEC_CONTRAST, SPEC_DEFAULT_ELEMENT_STYLE, SPEC_ELEMENT_STYLES, SPEC_FIELD_CLASS_BASELINE, SPEC_FLAVORS, SPEC_FLAVOR_PACKS, SPEC_FONTS, SPEC_FONT_ROLES, SPEC_LEGACY_ALIASES, SPEC_PALETTE_PRESETS, SPEC_SCHEMES, SPEC_SPRINGS, SPEC_TIERS, SPEC_TIER_IDS, SPEC_TOKEN_TYPES, SWISS_FLAVOR, USER_TOKEN_SOURCE, WCAG_AA_TEXT, apcaLc, applyElementStyle, applyHeadingLevelRule, buildFlavorTokens, buildFontFaceCss, catalogFontId, choicesForPack, colorSchemeClass, colorSchemeOf, compileSchemeCss, compileTokenCss, compileTokenCssBlocks, cssString, defaultDesignChoices, defaultElementStyleFor, deriveAccentTokens, deriveBrandTokens, designBaseline, designConfigEntries, designModeOf, designTokenRepairs, designTokenRows, elementStyleById, elementStyleClass, elementStylesFor, emptyImageLabelSrc, emptyImagePlaceholder, emptyImageSrc, flavorPackById, flavorSourceStamp, fontFamilyKey, fontFileName, fontFileStem, fontFormatOf, fontPreloads, fontRoleReferences, fontsForTokens, googleFontHref, groupFontFamilies, hasElementStyleMarker, isDesignTokenGroup, isDesignTokenTier, isDesignTokenType, isRetiredFlavorId, legacyRuleTokenReferences, matchFontWeight, missingDesignRows, nodeDesignClasses, normalizeFontStyle, normalizeFontWeight, oklabToRgb, ownedTraitStatus, packDesignChoices, parseFontFamilies, parseHexColor, planDesignApply, planFlavorRevert, planFlavorSeed, planFontFamilyRemoval, planSwissMigration, readDesignConfig, relativeLuminance, resolveDesignChoices, resolveTokenReferences, resolveTokenValues, revertAvailable, rgbToOklab, sameDesignChoices, specTokenNames, springToLinear, stackNamesFamily, styleKeyToKebab, switchElementStyle, syncNodeDesignClasses, toHexColor, tokenReferences, tokensToDarkVarMap, tokensToVarMap, unknownTokenReferences, userFontStack, validateFlavorPack, wcagContrastRatio };
+export { ACCENT_TOKEN_NAMES, BUTTON_VARIANT_TO_STYLE, COLOR_SCHEMES, COLOR_SCHEME_TRAIT, COLOR_SCHEME_TYPES, ColorScheme, DEFAULT_FLAVOR_ID, DESIGN_TOKEN_GROUPS, DESIGN_TOKEN_TIERS, DESIGN_TOKEN_TYPES, DesignConfigKey, ELEMENT_STYLES, ELEMENT_STYLE_MARKER_CLASS, ELEMENT_STYLE_STATES, EMPTY_IMAGE_ATTRIBUTE, EMPTY_IMAGE_SRC, ElementStyleState, FLAVOR_SPEC_VERSION, FONT_CATALOG, FONT_FAMILY_TOKENS, FONT_FILE_ACCEPT, FONT_FILE_EXTENSIONS, FONT_FILE_FORMATS, FONT_STYLES, FONT_WEIGHTS, FontUploadError, GOOGLE_FONTS_CSS_ORIGIN, GOOGLE_FONTS_FILE_ORIGIN, MAX_FONT_FILE_BYTES, OwnedTraitLink, PALETTE_PRESETS, REDUCED_MOTION_OVERRIDES, REDUCED_TRANSPARENCY_OVERRIDES, REVERT_WINDOW_MS, SPEC_A11Y, SPEC_AXES, SPEC_BUTTON_VARIANT_TO_STYLE, SPEC_CONTRAST, SPEC_DEFAULT_ELEMENT_STYLE, SPEC_ELEMENT_STYLES, SPEC_FIELD_CLASS_BASELINE, SPEC_FLAVORS, SPEC_FLAVOR_PACKS, SPEC_FONTS, SPEC_FONT_ROLES, SPEC_LEGACY_ALIASES, SPEC_PALETTE_PRESETS, SPEC_SCHEMES, SPEC_SPRINGS, SPEC_TIERS, SPEC_TIER_IDS, SPEC_TOKEN_TYPES, SWISS_FLAVOR, USER_TOKEN_SOURCE, WCAG_AA_TEXT, apcaLc, applyElementStyle, applyHeadingLevelRule, buildFlavorTokens, buildFontFaceCss, catalogFontId, checkFontWeight, choicesForPack, colorSchemeClass, colorSchemeOf, compareFontWeights, compileSchemeCss, compileTokenCss, compileTokenCssBlocks, cssString, defaultDesignChoices, defaultElementStyleFor, deriveAccentTokens, deriveBrandTokens, designBaseline, designConfigEntries, designModeOf, designTokenRepairs, designTokenRows, elementStyleById, elementStyleClass, elementStylesFor, emptyImageLabelSrc, emptyImagePlaceholder, emptyImageSrc, flavorPackById, flavorSourceStamp, fontFamilyKey, fontFileName, fontFileStem, fontFormatOf, fontPreloads, fontRoleReferences, fontStackWithout, fontWeightCovers, fontWeightRange, fontWeightValue, fontsForTokens, formatFontFamilies, formatFontFamily, formatFontWeight, googleFontHref, groupFontFamilies, hasElementStyleMarker, isDesignTokenGroup, isDesignTokenTier, isDesignTokenType, isFontWeightRange, isRetiredFlavorId, legacyRuleTokenReferences, matchFontWeight, missingDesignRows, missingFontRoles, nodeDesignClasses, normalizeFontStyle, normalizeFontWeight, normalizeFontWeightValue, oklabToRgb, ownedTraitStatus, packDesignChoices, parseFontFamilies, parseFontWeight, parseHexColor, planDesignApply, planFlavorRevert, planFlavorSeed, planFontFamilyRemoval, planSwissMigration, previewFontWeight, readDesignConfig, relativeLuminance, resolveDesignChoices, resolveTokenReferences, resolveTokenValues, revertAvailable, rgbToOklab, sameDesignChoices, specTokenNames, springToLinear, stackNamesFamily, styleKeyToKebab, switchElementStyle, syncNodeDesignClasses, toHexColor, tokenReferences, tokensToDarkVarMap, tokensToVarMap, unknownTokenReferences, userFontStack, validateFlavorPack, wcagContrastRatio };
 //# sourceMappingURL=vectoriox-iox-ui-design-core.mjs.map