tosijs-ui 1.16.18 → 1.16.20

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 1.16.20
+
+- **A registered icon with style suffixes wins over a composition rule.** `checkCircle90r`
+  drew the `check` rule over a rotated `circle`; it is now `checkCircle` turned 90°, in the
+  renderer and in `iconSvg`. A rule still applies where the whole name is not a registered
+  icon with suffixes (`checkLock90r`). closes board #3295
+- **`defineIcons` warns when a new name it defines is also what a composition rule would
+  draw** ("icon checkFoo is also a composition rule's name; your definition wins"). Only a
+  name that reads as the rule's warns (`checkFoo`, not `checkbox` or `unlink`), and
+  overriding a name that already exists, a built-in such as `unlock` included, never does.
+- **A redirect to a missing icon names what was asked for.** `defineIcons({ myChevron:
+  'chevronDwon' })` warned "icon chevronDwon does not exist", naming only the target; it
+  now adds "(requested as myChevron)", through stacks too. closes board #3294
+- **Six live examples on the doc site showed nothing; a Playwright spec now fails on any
+  that does.**
+  - The table's Column Width section rendered an empty `<tosi-table>` (an `html` fence
+    meant as syntax). It is now a live before/after with a test.
+  - The router page's examples shared the page's one router, so the last to run blanked
+    the others. Basic Usage holds it on load and has links; Named Views routes when you
+    press its button, and a test checks the first example shows its route.
+  - Code meant to be read no longer runs as an empty example: the token-palette `css` on
+    highlight-block and highlight-styles, liveTheme's programmatic-control snippet, and the
+    migrating guide's setSchemaValidator lines are `:static`.
+
+## 1.16.19
+
+- **`iconSvg()` resolves the built-in icons that rotate or flip another.** 27 built-in
+  names are redirects with a rotation or flip (`chevronDown` is `chevronRight90r`; also
+  `chevronLeft`/`Up`, `arrowDown`/`Left`/`Up`, `cornerDownLeft`, `rotateCcw`, `thumbsDown`
+  and others), and `iconSvg()` returned `undefined` for every one of them, silently. They
+  now return markup with the transform applied about the centre of the viewBox. A rotation
+  or flip written inline (`iconSvg('chevronRight90r')`) and other inline names returned
+  undefined silently too: a rotation or flip now resolves, and anything else throws. A Playwright
+  test draws each one both ways, through `iconSvg` and through `icons.<name>()`, and
+  finds no pixel that differs by more than antialiasing, in all three browsers.
+- **`iconSvg()` throws for a name it cannot turn into one SVG.** A stack
+  (`cloudSync: 'spin120Loader40s_30x$cloud'`, or `tosi$hat` written inline), a rule
+  (`unLock`, `spin90Loader`), a style suffix other than rotation or flip (`check50o`), a
+  redirect to a name that is not an icon, or a redirect cycle all returned `undefined`,
+  the same answer as a name that does not exist, so a build script rendered nothing and
+  said nothing. Each now throws, saying which it is and, where the icon renderer would draw
+  it, that `icons.<name>()` does so where there is a DOM. **Code that relied on `undefined`
+  for those names now gets an exception;** a name nothing would draw still returns
+  `undefined`, as documented. This is the follow-up to #224, for the DOM-free path.
+- `iconSvg()` reads suffixes with the same grammar as the icon renderer, now shared
+  between them: `edit2_90r` is `edit2` turned 90°, not -90°.
+
 ## 1.16.18
 
 - **A `defineIcons` name for a stacked composition draws the stack.** `defineIcons({

package/dist/data-table.js

@@ -948,10 +948,38 @@ by adding the `noreorder` attribute to the `<tosi-table>`.
 
 Columns are laid out at the widths you give them, so a table whose columns add up to less
 than its container leaves a strip of blank space on the right. Add the `full-width-header`
-attribute and the leftover space goes to the last **unpinned** column instead:
+attribute (`fullWidthHeader: true` from the creator) and the leftover space goes to the last
+**unpinned** column instead. The same columns, without and with it:
 
-```html
-<tosi-table full-width-header></tosi-table>
+```js
+import { tosiTable } from 'tosijs-ui'
+
+const array = [
+  { id: 1, name: 'Ada', role: 'Analyst' },
+  { id: 2, name: 'Grace', role: 'Admiral' },
+  { id: 3, name: 'Margaret', role: 'Director' },
+]
+const columns = () => [
+  { prop: 'id', name: 'ID', width: 60 },
+  { prop: 'name', name: 'Name', width: 120 },
+  { prop: 'role', name: 'Role', width: 120 },
+]
+const style = { display: 'block', height: '150px' }
+preview.append(
+  tosiTable({ array, columns: columns(), style }),
+  tosiTable({ array, columns: columns(), style, fullWidthHeader: true })
+)
+```
+```test
+const roleWidth = (table) =>
+  [...table.querySelectorAll('.thead .th')].at(-1).getBoundingClientRect().width
+test('only the full-width table stretches its last column', async () => {
+  const [plain, full] = preview.querySelectorAll('tosi-table')
+  for (let i = 0; i < 100 && !full.querySelector('.thead .th'); i++) await waitMs(20)
+  expect(full.hasAttribute('full-width-header')).toBe(true)
+  expect(Math.round(roleWidth(plain))).toBe(120)
+  expect(roleWidth(full)).toBeGreaterThan(120)
+})
 ```
 
 Right-pinned columns are skipped because they sit against the right edge by definition —

package/dist/doc-system/highlight-styles.js

@@ -23,7 +23,7 @@ ensureHighlightStyles()
 Every colour is a `varDefault`, so retheme any single token type — in either mode —
 by setting its variable:
 
-```css
+```css:static
 :root { --token-keyword: rebeccapurple; }
 ```
 

package/dist/highlight-block.js

@@ -43,7 +43,7 @@ shipped failing WCAG AA on every token type.
 
 Every colour is a `varDefault`, so retheme one token type without touching the rest:
 
-```css
+```css:static
 :root { --token-keyword: rebeccapurple; }
 ```
 

package/dist/icon-rules.d.ts

@@ -0,0 +1,20 @@
+import type { ElementPart } from 'tosijs';
+export interface IconRule {
+    prefix: string | RegExp;
+    apply: (baseName: string, match: RegExpMatchArray | string, parts: ElementPart[]) => Element | string | null;
+}
+/** A registered icon, or style suffixes on one (`chevronRight50o`). */
+export declare function canResolve(name: string): boolean;
+/**
+ * `spinN<Icon>` animates, so it is drawn by the DOM renderer, which installs `apply` when
+ * it loads. Its prefix is here so that every module knows the rule exists.
+ */
+export declare const spinRule: IconRule;
+export declare const iconRules: IconRule[];
+/** The icon a rule would apply to in `name`, or null if the rule does not match it. */
+export declare function matchRule(rule: IconRule, name: string): {
+    baseName: string;
+    match: RegExpMatchArray | string;
+} | null;
+/** Whether some rule would draw `name`: it matches, and the icon it applies to exists. */
+export declare const ruleDraws: (name: string) => boolean;

package/dist/icon-rules.js

@@ -0,0 +1,72 @@
+/*
+Composition rules (`spinNLoader`, `unLock`, `checkFile`, …) and how a name is matched to
+one, in ONE place. `icons.ts` (the DOM renderer) draws through them; `icon-svg.ts` (markup
+without a DOM) asks the same question, "would the renderer draw this name?", so it can tell
+a rule it cannot render from a name nothing would draw. It once guessed rules from the shape
+of a name instead, and threw for `redLock`. DOM-free, so `icon-svg.ts` can import it.
+
+Rules an app adds with `iconRules.push()` are seen by both, as long as they are pushed
+before the name is asked for.
+*/
+import iconData from './icon-data.js';
+import { splitSuffixes } from './icon-suffixes.js';
+/** A registered icon, or style suffixes on one (`chevronRight50o`). */
+export function canResolve(name) {
+    const data = iconData;
+    if (data[name])
+        return true;
+    const split = splitSuffixes(name);
+    return split != null && !!data[split.baseName];
+}
+/**
+ * `spinN<Icon>` animates, so it is drawn by the DOM renderer, which installs `apply` when
+ * it loads. Its prefix is here so that every module knows the rule exists.
+ */
+export const spinRule = {
+    prefix: /^spin(_?\d+)/,
+    apply() {
+        throw new Error('spin icons are drawn by the icon renderer (tosijs-ui/icons)');
+    },
+};
+export const iconRules = [
+    spinRule,
+    {
+        prefix: 'un',
+        apply: (baseName) => `slash25o$${baseName}75s75o`,
+    },
+    {
+        prefix: 'check',
+        apply: (baseName) => `check75o_00aa00S$${baseName}75s50o`,
+    },
+    {
+        prefix: 'cancel',
+        apply: (baseName) => `x75o_cc0000S$${baseName}75s50o`,
+    },
+    {
+        prefix: 'search',
+        apply: (baseName) => `search80s30x30y$${baseName}50o`,
+    },
+];
+/** The icon a rule would apply to in `name`, or null if the rule does not match it. */
+export function matchRule(rule, name) {
+    if (rule.prefix instanceof RegExp) {
+        const m = name.match(new RegExp(rule.prefix.source + '(.+)$'));
+        if (!m)
+            return null;
+        const tail = m[m.length - 1];
+        return { baseName: tail[0].toLowerCase() + tail.slice(1), match: m };
+    }
+    if (!name.startsWith(rule.prefix) || name.length <= rule.prefix.length) {
+        return null;
+    }
+    return {
+        baseName: name[rule.prefix.length].toLowerCase() +
+            name.slice(rule.prefix.length + 1),
+        match: rule.prefix,
+    };
+}
+/** Whether some rule would draw `name`: it matches, and the icon it applies to exists. */
+export const ruleDraws = (name) => iconRules.some((rule) => {
+    const matched = matchRule(rule, name);
+    return matched != null && canResolve(matched.baseName);
+});

package/dist/icon-suffixes.d.ts

@@ -0,0 +1,8 @@
+export declare const SUFFIX_RE: RegExp;
+/** A name split into its base and its suffix tokens, in order, or null if it has none. */
+export declare function splitSuffixes(name: string): {
+    baseName: string;
+    tokens: string[];
+} | null;
+/** The signed number in a numeric token: `_45r` is -45. */
+export declare const suffixNumber: (token: string) => number;

package/dist/icon-suffixes.js

@@ -0,0 +1,31 @@
+/*
+The icon style-suffix grammar, in ONE place. `icons.ts` (the DOM renderer) and
+`icon-svg.ts` (markup without a DOM) both read names through it. `icon-svg.ts` kept its own
+copy for one release candidate, and the two disagreed within a day: it read the `_` in
+`edit2_90r` as a minus sign and rotated the wrong way. DOM-free, so `icon-svg.ts` can
+import it.
+
+Suffixes are a value then a letter code:
+  50o (opacity), 75s (scale), 20x (translateX%), _10y (translateY%)
+  90r (rotate 90°), _45r (rotate -45°), 0f (flipH), 1f (flipV)
+  _FF0000F (fill hex), _f00S (stroke hex), 3W (stroke-width)
+  _brandColorF (fill var), _accentS (stroke var)
+Icon names ending in digits need a _ separator: edit2_50o
+*/
+export const SUFFIX_RE = /(?:(?<=[a-zA-Z_])(?:_?\d+[osxyr]|[01]f|\d+W)|_[a-zA-Z0-9]+[FS])+$/;
+const SUFFIX_TOKEN_RE = /_?\d+[osxyr]|[01]f|_[a-zA-Z0-9]+[FS]|\d+W/g;
+/** A name split into its base and its suffix tokens, in order, or null if it has none. */
+export function splitSuffixes(name) {
+    const match = name.match(SUFFIX_RE);
+    if (!match)
+        return null;
+    let baseName = name.slice(0, match.index);
+    // Strip the trailing _ separator (for digit-ending names: edit2_50o)
+    if (baseName.endsWith('_'))
+        baseName = baseName.slice(0, -1);
+    if (!baseName)
+        return null;
+    return { baseName, tokens: match[0].match(SUFFIX_TOKEN_RE) };
+}
+/** The signed number in a numeric token: `_45r` is -45. */
+export const suffixNumber = (token) => parseInt(token.replace('_', '-'));

package/dist/icon-svg.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Raw SVG markup for an icon, or `undefined` when nothing by that name would draw.
+ *
+ * Throws when the name would draw but cannot be one SVG string: a stack (`a$b`), a rule
+ * (`spin…`, `un…`), a style suffix other than rotation or flip, a redirect to a name that
+ * is not an icon, or a redirect cycle. Those need `icons.<name>()` where there is a DOM.
+ */
 export declare function iconSvg(name: string): string | undefined;
 /** Every icon name currently registered, including any added via defineIcons. */
 export declare function iconNames(): string[];

package/dist/icon-svg.js

@@ -5,7 +5,7 @@
 ```js
 import { iconSvg, iconNames } from 'tosijs-ui'
 
-const markup = iconSvg('tosi') // '<svg …>…</svg>' | undefined
+const markup = iconSvg('tosi') // '<svg …>…</svg>', or undefined for an unknown name
 preview.innerHTML =
   `<p>${iconNames().length} icons registered.</p>` +
   `<div style="width:48px">${markup}</div>`
@@ -19,6 +19,14 @@ what the live-example runner can rewrite.)
 is registered. Neither touches the DOM, so both work in a build script, a server-rendered
 template, or an ePub pass.
 
+Redirects are followed, including the built-in ones that rotate or flip another icon
+(`chevronDown` is `chevronRight90r`), and a rotation or flip written inline works too
+(`iconSvg('chevronRight90r')`). A name the icon renderer would draw but that cannot be one
+SVG string **throws**, saying why: a stack (`a$b`), a rule (`spin90Loader`, `unLock`), any
+other style suffix (`check50o`), a redirect to a name that is not an icon, or a redirect
+cycle. Render those with `icons.<name>()` where there is a DOM; the suffixes and rules are
+described on the [[icons]] page. Only a name that nothing would draw returns `undefined`.
+
 Deliberately a separate module from `icons.ts`: that one imports tosijs to build
 elements, so importing it drags in code that needs `HTMLElement` and throws in a build
 script — the exact context that wanted the markup in the first place. This module
@@ -32,18 +40,79 @@ resorted to when putting its own logo on a generated page. There is nothing to p
 the map ships in the bundle either way.
 */
 import iconData from './icon-data.js';
+import { splitSuffixes, suffixNumber } from './icon-suffixes.js';
+import { canResolve, ruleDraws } from './icon-rules.js';
+const data = iconData;
+// Rotation and flip, the only suffixes the built-in redirects use (`chevronDown` is
+// `chevronRight90r`). Anything else needs the DOM renderer.
+const isGeometry = (token) => /^(_?\d+r|[01]f)$/.test(token);
+const stripEscape = (name) => name.endsWith('_') ? name.slice(0, -1) : name;
+// Whether the icon renderer would draw something for a name: a registered icon, suffixes on
+// one (`chevronRight50o`), a stack (`a$b`), or a rule applied to one (`spin90Loader`,
+// `unLock`). The rules and suffixes are the renderer's own (icon-rules, icon-suffixes).
+const isComposition = (name) => name.includes('$') || canResolve(name) || ruleDraws(name);
+/**
+ * Raw SVG markup for an icon, or `undefined` when nothing by that name would draw.
+ *
+ * Throws when the name would draw but cannot be one SVG string: a stack (`a$b`), a rule
+ * (`spin…`, `un…`), a style suffix other than rotation or flip, a redirect to a name that
+ * is not an icon, or a redirect cycle. Those need `icons.<name>()` where there is a DOM.
+ */
 export function iconSvg(name) {
-    const data = iconData;
-    let key = name.endsWith('_') ? name.slice(0, -1) : name;
-    for (let i = 0; i < 10; i++) {
-        const value = data[key];
-        if (value === undefined)
-            return undefined;
+    const key = stripEscape(name);
+    if (!isComposition(key))
+        return undefined;
+    return resolve(name, key, new Set());
+}
+function resolve(asked, name, seen) {
+    const key = stripEscape(name);
+    const value = data[key];
+    if (value !== undefined) {
         if (value.startsWith('<'))
             return value;
-        key = value; // a redirect to another icon's name
+        if (seen.has(key)) {
+            throw new Error(`iconSvg("${asked}"): the icon redirects in a cycle`);
+        }
+        seen.add(key);
+        return resolve(asked, value, seen);
+    }
+    // The renderer's order for a name that is not registered: a stack, then suffixes on a
+    // registered icon (they win over a rule, #3295), then a rule.
+    const split = key.includes('$') ? null : splitSuffixes(key);
+    if (split &&
+        data[split.baseName] !== undefined &&
+        split.tokens.every(isGeometry)) {
+        return transformed(asked, resolve(asked, split.baseName, seen), split.tokens);
+    }
+    const what = key === stripEscape(asked) ? `"${key}"` : `it resolves to "${key}", which`;
+    if (isComposition(key)) {
+        throw new Error(`iconSvg("${asked}"): ${what} is not a single SVG (a stack, a rule, or a style ` +
+            `suffix other than rotation or flip). Render it with icons.${stripEscape(asked)}() ` +
+            `where there is a DOM.`);
+    }
+    throw new Error(`iconSvg("${asked}"): it redirects to "${key}", which is not a registered icon`);
+}
+// Apply rotate/flip suffixes about the centre of the viewBox, as the DOM renderer does
+// with `transform-origin: 50% 50%`.
+function transformed(asked, svg, tokens) {
+    const parts = svg.match(/^(\s*<svg\b[^>]*>)([\s\S]*)(<\/svg>\s*)$/);
+    const viewBox = parts?.[1]
+        .match(/viewBox="([^"]+)"/)?.[1]
+        .split(/[\s,]+/)
+        .map(Number);
+    if (!parts || !viewBox || viewBox.length !== 4 || viewBox.some(isNaN)) {
+        throw new Error(`iconSvg("${asked}"): cannot transform an icon without a viewBox`);
     }
-    return undefined; // redirect loop — treat as missing rather than hang
+    const [x, y, width, height] = viewBox;
+    const cx = x + width / 2;
+    const cy = y + height / 2;
+    const ops = tokens.map((token) => token.endsWith('r')
+        ? `rotate(${suffixNumber(token)})`
+        : token === '0f'
+            ? 'scale(-1 1)'
+            : 'scale(1 -1)');
+    const transform = `translate(${cx} ${cy}) ${ops.join(' ')} translate(${-cx} ${-cy})`;
+    return `${parts[1]}<g transform="${transform}">${parts[2]}</g>${parts[3]}`;
 }
 /** Every icon name currently registered, including any added via defineIcons. */
 export function iconNames() {

package/dist/icons.d.ts

@@ -1,16 +1,12 @@
 import { ElementCreator, ElementPart } from 'tosijs';
 import { SVGIconMap } from './icon-types.js';
+export { iconRules, type IconRule } from './icon-rules.js';
 export declare const defineIcons: (newIcons: {
     [key: string]: string;
 }) => void;
 export { iconSvg, iconNames } from './icon-svg.js';
 export type { IconElement, IconName, SVGIconMap } from './icon-types.js';
 export declare const svg2DataUrl: (icon: Element, fill?: string, stroke?: string, strokeWidth?: number) => string;
-export interface IconRule {
-    prefix: string | RegExp;
-    apply: (baseName: string, match: RegExpMatchArray | string, parts: ElementPart[]) => Element | string | null;
-}
-export declare const iconRules: IconRule[];
 /** Wrap icon elements in a composite container (for custom function rules) */
 export declare function wrapIcon(prop: string, parts: ElementPart[], ...children: Element[]): HTMLSpanElement;
 /** Resolve an icon name through the full pipeline (redirects, suffixes, rules, stacking) */

package/dist/icons.js

@@ -564,8 +564,34 @@ copies or substantial portions of the Software.
 */
 import { elements, svgElements, Color, vars, varDefault, withAttributes, } from 'tosijs';
 import iconData from './icon-data.js';
+import { splitSuffixes, suffixNumber } from './icon-suffixes.js';
+import { iconRules, spinRule, matchRule, canResolve } from './icon-rules.js';
+export { iconRules } from './icon-rules.js';
 export const defineIcons = (newIcons) => {
+    const data = iconData;
+    const isNew = Object.keys(newIcons).filter((name) => !data[name]);
     Object.assign(iconData, newIcons);
+    /*
+    A defined icon always wins over a composition rule that would produce the same name, but
+    the author may not know the rule exists. Say so once, here, where the name was chosen, and
+    only for a NEW name that reads as the rule's: `checkTestShadow`, not `checkbox` or `unlink`
+    (a lowercase run is a word, not a prefix plus an icon, so icon packs stay quiet).
+    Overriding a name that already existed, a built-in such as `unlock` or `checkCircle`
+    included, is a deliberate choice of that name and never warns, so neither does defining a
+    name a second time.
+    */
+    for (const name of isNew) {
+        const readsAsRule = iconRules.some((rule) => {
+            const matched = matchRule(rule, name);
+            if (matched == null || !canResolve(matched.baseName))
+                return false;
+            return (typeof rule.prefix !== 'string' ||
+                /[A-Z]/.test(name[rule.prefix.length]));
+        });
+        if (readsAsRule) {
+            console.warn(`icon ${name} is also a composition rule's name; your definition wins`);
+        }
+    }
 };
 // Raw-markup accessors live in ./icon-svg (DOM-free) and are re-exported here.
 export { iconSvg, iconNames } from './icon-svg.js';
@@ -629,47 +655,28 @@ export const svg2DataUrl = (icon, fill, stroke, strokeWidth) => {
 };
 // Appends _ to names ending in digits to prevent suffix ambiguity
 const safeIconSuffix = (name) => /\d$/.test(name) ? name + '_' : name;
-export const iconRules = [
-    {
-        prefix: /^spin(_?\d+)/,
-        apply(baseName, match, parts) {
-            const dps = match[1].replace('_', '-');
-            const duration = 360 / Math.abs(parseFloat(dps));
-            const direction = dps.startsWith('-') ? 'reverse' : 'normal';
-            // Resolve baseName with suffixes intact — they apply to the icon
-            const icon = resolveIcon(baseName, []);
-            const el = icon;
-            if (el.animate) {
-                const base = el.style.transform || '';
-                el.animate([
-                    { transform: `${base} rotate(0deg)` },
-                    { transform: `${base} rotate(360deg)` },
-                ], {
-                    duration: duration * 1000,
-                    iterations: Infinity,
-                    direction,
-                });
-            }
-            return wrapIcon(baseName, parts, icon);
-        },
-    },
-    {
-        prefix: 'un',
-        apply: (baseName) => `slash25o$${baseName}75s75o`,
-    },
-    {
-        prefix: 'check',
-        apply: (baseName) => `check75o_00aa00S$${baseName}75s50o`,
-    },
-    {
-        prefix: 'cancel',
-        apply: (baseName) => `x75o_cc0000S$${baseName}75s50o`,
-    },
-    {
-        prefix: 'search',
-        apply: (baseName) => `search80s30x30y$${baseName}50o`,
-    },
-];
+// The rule list and how names match it live in icon-rules.ts, shared with iconSvg. Spin
+// animates, so its renderer is installed here.
+spinRule.apply = (baseName, match, parts) => {
+    const dps = match[1].replace('_', '-');
+    const duration = 360 / Math.abs(parseFloat(dps));
+    const direction = dps.startsWith('-') ? 'reverse' : 'normal';
+    // Resolve baseName with suffixes intact — they apply to the icon
+    const icon = resolveIcon(baseName, []);
+    const el = icon;
+    if (el.animate) {
+        const base = el.style.transform || '';
+        el.animate([
+            { transform: `${base} rotate(0deg)` },
+            { transform: `${base} rotate(360deg)` },
+        ], {
+            duration: duration * 1000,
+            iterations: Infinity,
+            direction,
+        });
+    }
+    return wrapIcon(baseName, parts, icon);
+};
 let iconIdCounter = 0;
 function makeIcon(spec, parts) {
     const div = elements.div();
@@ -748,38 +755,13 @@ export function wrapIcon(prop, parts, ...children) {
     }
     return wrapper;
 }
-function canResolve(name) {
-    const data = iconData;
-    if (data[name])
-        return true;
-    const parsed = parseStyleSuffixes(name);
-    return parsed != null && !!data[parsed.baseName];
-}
 function composeIcon(prop, parts) {
     for (const rule of iconRules) {
-        let baseName;
-        let match;
-        if (rule.prefix instanceof RegExp) {
-            const re = new RegExp(rule.prefix.source + '(.+)$');
-            const m = prop.match(re);
-            if (!m)
-                continue;
-            baseName = m[m.length - 1];
-            baseName = baseName[0].toLowerCase() + baseName.slice(1);
-            match = m;
-        }
-        else {
-            if (!prop.startsWith(rule.prefix) || prop.length <= rule.prefix.length)
-                continue;
-            baseName =
-                prop[rule.prefix.length].toLowerCase() +
-                    prop.slice(rule.prefix.length + 1);
-            match = rule.prefix;
-        }
+        const matched = matchRule(rule, prop);
         // Only apply if baseName can actually resolve to an icon
-        if (!canResolve(baseName))
+        if (!matched || !canResolve(matched.baseName))
             continue;
-        const result = rule.apply(safeIconSuffix(baseName), match, parts);
+        const result = rule.apply(safeIconSuffix(matched.baseName), matched.match, parts);
         if (typeof result === 'string')
             return resolveIcon(result, parts);
         if (result)
@@ -789,41 +771,20 @@ function composeIcon(prop, parts) {
 }
 // Redirect names being resolved right now, so a redirect cycle ends instead of recursing.
 const expanding = new Set();
-// Style suffixes — value then letter code:
-//   50o (opacity), 75s (scale), 20x (translateX%), _10y (translateY%)
-//   90r (rotate 90°), _45r (rotate -45°), 0f (flipH), 1f (flipV)
-//   _FF0000F (fill hex), _f00S (stroke hex), 3W (stroke-width)
-//   _brandColorF (fill var), _accentS (stroke var)
-// Icon names ending in digits need _ separator: edit2_50o
-const SUFFIX_RE = /(?:(?<=[a-zA-Z_])(?:_?\d+[osxyr]|[01]f|\d+W)|_[a-zA-Z0-9]+[FS])+$/;
+// The suffix grammar lives in icon-suffixes.ts, shared with iconSvg.
 function parseStyleSuffixes(name) {
-    const match = name.match(SUFFIX_RE);
-    if (!match)
-        return null;
-    let baseName = name.slice(0, match.index);
-    if (!baseName)
-        return null;
-    // Strip trailing _ separator (for digit-ending names: edit2_50o)
-    if (baseName.endsWith('_'))
-        baseName = baseName.slice(0, -1);
-    if (!baseName)
+    const split = splitSuffixes(name);
+    if (!split)
         return null;
+    const { baseName } = split;
     const data = iconData;
     // Accept if baseName is in iconData, or matches a composition rule prefix
     if (!data[baseName]) {
-        const matchesRule = iconRules.some((rule) => {
-            if (rule.prefix instanceof RegExp) {
-                return rule.prefix.test(baseName);
-            }
-            return (baseName.startsWith(rule.prefix) && baseName.length > rule.prefix.length);
-        });
-        if (!matchesRule)
+        if (!iconRules.some((rule) => matchRule(rule, baseName)))
             return null;
     }
     const style = {};
-    const suffixes = match[0].match(/_?\d+[osxyr]|[01]f|_[a-zA-Z0-9]+[FS]|\d+W/g);
-    if (!suffixes)
-        return null;
+    const suffixes = split.tokens;
     const transforms = [];
     for (const s of suffixes) {
         const code = s[s.length - 1];
@@ -842,7 +803,7 @@ function parseStyleSuffixes(name) {
             style.strokeWidth = s.slice(0, -1);
         }
         else {
-            const val = parseInt(s.replace('_', '-'));
+            const val = suffixNumber(s);
             switch (code) {
                 case 'o':
                     style.opacity = String(val / 100);
@@ -934,19 +895,28 @@ export function resolveIcon(prop, parts) {
         });
         return wrapIcon(prop, parts, base, ...overlays);
     }
-    // Try composition (spin, un, check, etc.)
-    const composed = composeIcon(prop, parts);
-    if (composed)
-        return composed;
-    // Style suffixes — strip them, resolve the base, apply after
+    /*
+    Style suffixes on a registered icon win over a composition rule (#3295): `checkCircle90r`
+    is `checkCircle` turned, not the `check` rule over `circle90r`. A rule still applies
+    when its suffixes are on an icon that only the rule makes (`spin90Loader50o`).
+    */
     const parsed = parseStyleSuffixes(prop);
+    const native = parsed != null && iconData[parsed.baseName];
+    if (!native) {
+        const composed = composeIcon(prop, parts);
+        if (composed)
+            return composed;
+    }
     if (parsed) {
         const icon = resolveIcon(parsed.baseName, parts);
         Object.assign(icon.style, parsed.style);
         return icon;
     }
     if (prop) {
-        console.warn(`icon ${prop} does not exist`);
+        // Inside a redirect, also name what the caller asked for: a typo in a defineIcons
+        // target is otherwise reported under a name that appears nowhere in their code.
+        const via = expanding.size > 0 ? ` (requested as ${[...expanding].join(' → ')})` : '';
+        console.warn(`icon ${prop} does not exist${via}`);
     }
     return makeIcon(iconData.square, parts);
 }