@vectoriox/iox-ui 5.35.0 → 5.36.0

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

@@ -105,6 +105,896 @@ function removeFromComposite(root, node) {
     return true;
 }
 
+/**
+ * ACCORDION (CC2 — composite K1; complex-components boards 3, 4 and 9, APPROVED 2026-10-20). Not a
+ * component: a recipe of ordinary nodes, each part carrying a role, so every part is selectable on the
+ * canvas, in the layer tree and the breadcrumb, and wears its own element style (R2).
+ *
+ *   Container `box`                      role accordion      traits multiple · defaultOn   (Manual)
+ *     — or a Repeater bound to a list    role accordion      ONE template item             (From content, R3)
+ *   └─ Container `accordion-item`        role accordion.item      itemKey k1 … (Manual) · the row's id (From content)
+ *       ├─ LinkedContainer `accordion-trigger`  role accordion.trigger   → <hN><button> (the question's level)
+ *       │   ├─ Heading `h3`               the question (rendered as phrasing inside the button)
+ *       │   └─ Icon `icon`                role accordion.icon      Item open → rotate
+ *       └─ Container `accordion-panel`    role accordion.panel     inside a hidden="until-found" region
+ *           └─ Text `body`                the answer
+ *
+ * The behaviour is BUILT IN (composite plan D1 = B): which items are open is one state machine
+ * (`nextAccordionState`), the ARIA and DOM state one planner (`accordionItemState` and the attribute
+ * functions), the keyboard one key map — read by the builder canvas, both engine paths and the composer.
+ */
+var AccordionRole;
+(function (AccordionRole) {
+    AccordionRole["Accordion"] = "accordion";
+    AccordionRole["Item"] = "accordion.item";
+    AccordionRole["Trigger"] = "accordion.trigger";
+    AccordionRole["Icon"] = "accordion.icon";
+    AccordionRole["Panel"] = "accordion.panel";
+})(AccordionRole || (AccordionRole = {}));
+/** The behaviour options a composite root stores as ordinary TRAITS (composite plan §3). */
+var CompositeBehaviourTrait;
+(function (CompositeBehaviourTrait) {
+    /** Several items may be open at once ("Allow several open"). */
+    CompositeBehaviourTrait["Multiple"] = "multiple";
+    /** Which items open by default: first · none · all. */
+    CompositeBehaviourTrait["DefaultOn"] = "defaultOn";
+})(CompositeBehaviourTrait || (CompositeBehaviourTrait = {}));
+var AccordionDefaultOn;
+(function (AccordionDefaultOn) {
+    AccordionDefaultOn["First"] = "first";
+    AccordionDefaultOn["None"] = "none";
+    AccordionDefaultOn["All"] = "all";
+})(AccordionDefaultOn || (AccordionDefaultOn = {}));
+const ACCORDION_DEFAULT_ONS = [AccordionDefaultOn.First, AccordionDefaultOn.None, AccordionDefaultOn.All];
+/** Behaviour ▸ Icon — a preset over the items' icons, never a stored trait (detected from the icons). */
+var AccordionIcon;
+(function (AccordionIcon) {
+    AccordionIcon["Chevron"] = "chevron";
+    AccordionIcon["Plus"] = "plus";
+    AccordionIcon["None"] = "none";
+})(AccordionIcon || (AccordionIcon = {}));
+const ACCORDION_ICONS = [AccordionIcon.Chevron, AccordionIcon.Plus, AccordionIcon.None];
+/** Each icon's glyph and how far it turns when its item opens (board 4: a chevron flips, a plus becomes ×). */
+const ACCORDION_ICON_GLYPH = {
+    [AccordionIcon.Chevron]: { iconClass: 'ph ph-caret-down', turn: '180deg' },
+    [AccordionIcon.Plus]: { iconClass: 'ph ph-plus', turn: '45deg' },
+};
+/** The item-open style state (a part INSIDE an item, styled by its item being open — board 9 "Item open"). */
+const ITEM_OPEN_STATE = 'trigger-on';
+/** A part that IS on (an item, its header, its panel — board 9 "Open"). */
+const ON_STATE = 'on';
+/** Items from content default to twenty rows (board 9 Q13). */
+const ACCORDION_CONTENT_LIMIT = 20;
+/** The words a fresh accordion starts with — generic, the author's to replace (as Card v2's are). */
+const ACCORDION_WORDS = [
+    { question: 'Write the first question people ask', answer: 'Answer it plainly, in two or three short sentences.' },
+    { question: 'Write the second question', answer: 'Answer it plainly, in two or three short sentences.' },
+    { question: 'Write the third question', answer: 'Answer it plainly, in two or three short sentences.' },
+];
+const ACCORDION_NEW_ITEM_WORDS = { question: 'Write a new question', answer: 'Answer it plainly, in two or three short sentences.' };
+var Type$1;
+(function (Type) {
+    Type["Container"] = "Container";
+    Type["LinkedContainer"] = "LinkedContainer";
+    Type["Heading"] = "Heading";
+    Type["Text"] = "Text";
+    Type["Icon"] = "Icon";
+    Type["Repeater"] = "Repeater";
+})(Type$1 || (Type$1 = {}));
+var Style$1;
+(function (Style) {
+    Style["Root"] = "box";
+    Style["Item"] = "accordion-item";
+    Style["Trigger"] = "accordion-trigger";
+    Style["Question"] = "h3";
+    Style["Icon"] = "icon";
+    Style["Panel"] = "accordion-panel";
+    Style["Answer"] = "body";
+})(Style$1 || (Style$1 = {}));
+const ZERO_BOX$1 = '0px 0px 0px 0px';
+const HEADING_LEVELS = ['h2', 'h3', 'h4', 'h5', 'h6'];
+const DEFAULT_LEVEL = 'h3';
+/** A linked trait the header must never carry: it is a button, not a link. */
+const LINK_TYPE$1 = 'linkType';
+/** What each part holds in the recipe — layout only; its LOOK is its element style. */
+const PART_BASE = {
+    // The items are a column a token apart (`accordion-gap`: 0 for a divider list, 12px for cards).
+    [AccordionRole.Accordion]: { display: 'flex', flexDirection: 'column', gap: 'var(--iox-accordion-gap)', width: '100%', minHeight: 'auto', height: 'auto' },
+    [AccordionRole.Item]: { display: 'block', width: '100%', minHeight: 'auto', height: 'auto' },
+    // The header is the whole row: the question takes the line, the icon sits at its end (board 4).
+    [AccordionRole.Trigger]: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: '16px', width: '100%', minHeight: 'auto', height: 'auto', textAlign: 'start', cursor: 'pointer' },
+    [AccordionRole.Icon]: { flexShrink: '0', fontSize: '22px', transitionDuration: 'var(--iox-dur-base)', transitionTimingFunction: 'var(--iox-ease-standard)' },
+    [AccordionRole.Panel]: { display: 'block', width: '100%', minHeight: 'auto', height: 'auto' },
+};
+/** The question INHERITS the header's ink (board 4's wears table: the Question reads no colour token), so the
+ *  header's hover ink reaches the words; and it sits in the row with no margin of its own. */
+const QUESTION_BASE = { color: 'inherit', margin: ZERO_BOX$1, flexGrow: '1', minWidth: '0px' };
+const ANSWER_BASE = { margin: ZERO_BOX$1, padding: ZERO_BOX$1, minHeight: 'auto' };
+function make$1(create, key, type, role, style, props = {}, label) {
+    const node = create({ key, type, props, elementStyle: style });
+    if (role)
+        node.role = role;
+    if (label)
+        node.label = label;
+    if (role && PART_BASE[role])
+        writeStyles(node, PART_BASE[role]);
+    return node;
+}
+/** The item's icon; its Item-open state (the turn) is driven by ITS item (`stateTriggers`). */
+function buildIcon(create, key, icon, itemId) {
+    const glyph = ACCORDION_ICON_GLYPH[icon];
+    const node = make$1(create, key, Type$1.Icon, AccordionRole.Icon, Style$1.Icon, { iconClass: glyph.iconClass }, 'Icon');
+    node.stateStyles = { ...(node.stateStyles ?? {}), [ITEM_OPEN_STATE]: { rotate: glyph.turn } };
+    if (itemId)
+        node.stateTriggers = { ...(node.stateTriggers ?? {}), [ITEM_OPEN_STATE]: itemId };
+    return node;
+}
+/** One item: header (question + icon) and panel (answer). `key` makes every part's recipe key unique. */
+function buildAccordionItem(create, words, itemKey, icon = AccordionIcon.Chevron) {
+    const item = make$1(create, `${itemKey}`, Type$1.Container, AccordionRole.Item, Style$1.Item, {}, 'Item');
+    item.itemKey = itemKey;
+    const trigger = make$1(create, `${itemKey}-trigger`, Type$1.LinkedContainer, AccordionRole.Trigger, Style$1.Trigger, {}, 'Header');
+    const question = make$1(create, `${itemKey}-question`, Type$1.Heading, null, Style$1.Question, { content: words.question, level: DEFAULT_LEVEL }, 'Heading');
+    writeStyles(question, QUESTION_BASE);
+    trigger.children = [question, ...(icon === AccordionIcon.None ? [] : [buildIcon(create, `${itemKey}-icon`, icon, item.id)])];
+    const panel = make$1(create, `${itemKey}-panel`, Type$1.Container, AccordionRole.Panel, Style$1.Panel, {}, 'Panel');
+    const answer = make$1(create, `${itemKey}-answer`, Type$1.Text, null, Style$1.Answer, { content: words.answer, tag: 'p' }, 'Text');
+    writeStyles(answer, ANSWER_BASE);
+    panel.children = [answer];
+    item.children = [trigger, panel];
+    return item;
+}
+/** A fresh Accordion: three items, one open at a time, the first open by default (board 4). */
+function buildAccordionRecipe(create, options = {}) {
+    const root = make$1(create, 'accordion', Type$1.Container, AccordionRole.Accordion, Style$1.Root, {}, 'Accordion');
+    writeProp(root, CompositeBehaviourTrait.Multiple, options.multiple ?? false);
+    writeProp(root, CompositeBehaviourTrait.DefaultOn, options.defaultOn ?? AccordionDefaultOn.First);
+    const words = options.items ?? ACCORDION_WORDS;
+    root.children = words.map((w, i) => buildAccordionItem(create, w, `k${i + 1}`, options.icon ?? AccordionIcon.Chevron));
+    return root;
+}
+// ── reading a tree ──────────────────────────────────────────────────────────────────────────────
+function isAccordionRoot(node) {
+    return node?.role === AccordionRole.Accordion;
+}
+/** True for any part of an accordion (its root included). */
+function isAccordionPart(node) {
+    return !!node?.role && (node.role === AccordionRole.Accordion || node.role.startsWith(`${AccordionRole.Accordion}.`));
+}
+/** The accordion a node belongs to: the nearest ancestor (or the node itself) playing `accordion`.
+ *  `path` = the node's ancestors, root first. */
+function accordionRootOf(node, path) {
+    if (isAccordionRoot(node))
+        return node;
+    for (let i = path.length - 1; i >= 0; i--)
+        if (isAccordionRoot(path[i]))
+            return path[i];
+    return null;
+}
+/** The item a node sits in (the node itself when it is one), or null. */
+function accordionItemOf(node, path) {
+    if (node.role === AccordionRole.Item)
+        return node;
+    for (let i = path.length - 1; i >= 0; i--) {
+        if (path[i].role === AccordionRole.Item)
+            return path[i];
+        if (isAccordionRoot(path[i]))
+            return null;
+    }
+    return null;
+}
+/** True when the root takes its items from content (a Repeater bound to a list, R3). */
+function isAccordionFromContent(root) {
+    return !!root && root.type === Type$1.Repeater;
+}
+/** The root's items in order — every item (Manual), or the one template item (From content). */
+function accordionItems(root) {
+    return (root.children ?? []).filter(c => c.role === AccordionRole.Item);
+}
+const asBool = (v) => v === true || v === 'true';
+/** The root's behaviour (an unset trait reads its default: one at a time, the first open). */
+function accordionBehaviour(root) {
+    const raw = root ? readProp(root, CompositeBehaviourTrait.DefaultOn) : undefined;
+    const defaultOn = ACCORDION_DEFAULT_ONS.includes(raw) ? raw : AccordionDefaultOn.First;
+    return { multiple: root ? asBool(readProp(root, CompositeBehaviourTrait.Multiple)) : false, defaultOn };
+}
+/** Behaviour ▸ Allow several open / Open by default. False when the node has no such trait. */
+function setAccordionBehaviour(root, patch) {
+    let ok = true;
+    if (patch.multiple !== undefined)
+        ok = writeProp(root, CompositeBehaviourTrait.Multiple, patch.multiple) && ok;
+    if (patch.defaultOn !== undefined)
+        ok = writeProp(root, CompositeBehaviourTrait.DefaultOn, patch.defaultOn) && ok;
+    return ok;
+}
+/** The header of an item. */
+function accordionTriggerOf(item) {
+    return findByRole(item, AccordionRole.Trigger);
+}
+/** The panel of an item. */
+function accordionPanelOf(item) {
+    return findByRole(item, AccordionRole.Panel);
+}
+/** The question: the first Heading inside the header. */
+function accordionQuestionOf(item) {
+    const trigger = accordionTriggerOf(item);
+    let hit;
+    if (trigger)
+        walkComposite(trigger, n => { if (!hit && n.type === Type$1.Heading)
+            hit = n; });
+    return hit;
+}
+/** The answer: the first Text inside the panel. */
+function accordionAnswerOf(item) {
+    const panel = accordionPanelOf(item);
+    let hit;
+    if (panel)
+        walkComposite(panel, n => { if (!hit && n.type === Type$1.Text)
+            hit = n; });
+    return hit;
+}
+const stripTags = (v) => String(v ?? '').replace(/<[^>]*>/g, '').trim();
+/** An item's name in the Items list and the layer tree: its question's words. */
+function accordionItemLabel(item) {
+    const q = accordionQuestionOf(item);
+    return q ? stripTags(readProp(q, 'content')) : '';
+}
+/** Items ▸ rename: the question's words. */
+function renameAccordionItem(item, question) {
+    const q = accordionQuestionOf(item);
+    return !!q && writeProp(q, 'content', question);
+}
+/** The heading level the header's wrapper renders (`<h3><button>`): its question's level. */
+function accordionHeadingLevel(trigger) {
+    let level;
+    const visit = (n) => {
+        if (level !== undefined)
+            return;
+        if (n.type === Type$1.Heading) {
+            level = readProp(n, 'level');
+            return;
+        }
+        for (const c of n.children ?? [])
+            visit(c);
+    };
+    for (const c of trigger?.children ?? [])
+        visit(c);
+    return HEADING_LEVELS.includes(level) ? level : DEFAULT_LEVEL;
+}
+// ── editing (Items list, selection toolbar, Behaviour ▸ Icon) ──────────────────────────────────
+/** A key no item of `root` holds yet (`k4`…). */
+function nextItemKey(root) {
+    const taken = new Set(accordionItems(root).map(i => i.itemKey).filter(Boolean));
+    let n = taken.size + 1;
+    while (taken.has(`k${n}`))
+        n++;
+    return `k${n}`;
+}
+/** Items ▸ Add item (and the toolbar's "Add item"): a fresh item after `after` (or at the end), wearing the
+ *  accordion's current icon. Returns the new item. */
+function addAccordionItem(root, create, after, words = ACCORDION_NEW_ITEM_WORDS) {
+    const key = nextItemKey(root);
+    const item = buildAccordionItem(create, words, key, detectAccordionIcon(root));
+    const children = [...(root.children ?? [])];
+    const at = after ? children.indexOf(after) : -1;
+    children.splice(at < 0 ? children.length : at + 1, 0, item);
+    root.children = children;
+    return item;
+}
+/** Items ▸ drag to reorder: move an item to `toIndex` among the items. False when it is not an item of `root`. */
+function moveAccordionItem(root, item, toIndex) {
+    const children = [...(root.children ?? [])];
+    const from = children.indexOf(item);
+    if (from < 0 || item.role !== AccordionRole.Item)
+        return false;
+    children.splice(from, 1);
+    const items = children.filter(c => c.role === AccordionRole.Item);
+    const anchor = items[Math.max(0, Math.min(toIndex, items.length))];
+    const at = anchor ? children.indexOf(anchor) : children.length;
+    children.splice(at, 0, item);
+    root.children = children;
+    return true;
+}
+var AccordionEditRefusal;
+(function (AccordionEditRefusal) {
+    /** An accordion keeps at least one item (composite plan T11). */
+    AccordionEditRefusal["LastItem"] = "last-item";
+})(AccordionEditRefusal || (AccordionEditRefusal = {}));
+/** Why removing `item` from `root` is refused, or null. */
+function accordionRemovalRefusal(root, item) {
+    if (!root || item?.role !== AccordionRole.Item)
+        return null;
+    return accordionItems(root).length <= 1 ? AccordionEditRefusal.LastItem : null;
+}
+/** The icon the accordion's items wear now (the first item's; None when it has no icon). */
+function detectAccordionIcon(root) {
+    const first = accordionItems(root)[0];
+    const icon = first ? findByRole(first, AccordionRole.Icon) : undefined;
+    if (!icon)
+        return first ? AccordionIcon.None : AccordionIcon.Chevron;
+    const cls = String(readProp(icon, 'iconClass') ?? '');
+    return cls.includes(ACCORDION_ICON_GLYPH[AccordionIcon.Plus].iconClass.split(' ')[1]) ? AccordionIcon.Plus : AccordionIcon.Chevron;
+}
+/**
+ * Behaviour ▸ Icon: every item's header shows the chevron, the plus, or no icon. A switch between glyphs
+ * keeps the icon NODE (its styles and interactions) and changes its glyph and turn; None removes it, and a
+ * glyph after None stamps it back from the recipe. Returns how many items changed.
+ */
+function setAccordionIcon(root, icon, create) {
+    let changed = 0;
+    for (const item of accordionItems(root)) {
+        const trigger = accordionTriggerOf(item);
+        if (!trigger)
+            continue;
+        const existing = findByRole(trigger, AccordionRole.Icon);
+        if (icon === AccordionIcon.None) {
+            if (existing && removeFromComposite(trigger, existing))
+                changed++;
+            continue;
+        }
+        const glyph = ACCORDION_ICON_GLYPH[icon];
+        if (existing) {
+            writeProp(existing, 'iconClass', glyph.iconClass);
+            existing.stateStyles = { ...(existing.stateStyles ?? {}), [ITEM_OPEN_STATE]: { ...(existing.stateStyles?.[ITEM_OPEN_STATE] ?? {}), rotate: glyph.turn } };
+            changed++;
+        }
+        else if (create) {
+            trigger.children = [...(trigger.children ?? []), buildIcon(create, `${item.itemKey ?? 'item'}-icon`, icon, item.id)];
+            changed++;
+        }
+    }
+    return changed;
+}
+/** The node id every `trigger-on` state inside an item points at: its ITEM (`stateTriggers['trigger-on']`). */
+function itemOpenTriggerIds(root) {
+    for (const item of accordionItems(root)) {
+        if (!item.id)
+            continue;
+        walkComposite(item, n => {
+            if (n === item || !n.stateStyles?.[ITEM_OPEN_STATE])
+                return;
+            n.stateTriggers = { ...(n.stateTriggers ?? {}), [ITEM_OPEN_STATE]: item.id };
+        });
+    }
+}
+// ── state machine ───────────────────────────────────────────────────────────────────────────────
+/** The keys open on first render: the first item, none, or all (From content: resolved against the rows). */
+function initialAccordionOpen(keys, defaultOn) {
+    if (defaultOn === AccordionDefaultOn.None || !keys.length)
+        return new Set();
+    if (defaultOn === AccordionDefaultOn.All)
+        return new Set(keys);
+    return new Set([keys[0]]);
+}
+/** The open keys after toggling `key`: one at a time closes the others; several leaves them. */
+function nextAccordionState(open, key, behaviour) {
+    if (open.has(key)) {
+        const next = new Set(open);
+        next.delete(key);
+        return next;
+    }
+    return behaviour.multiple ? new Set([...open, key]) : new Set([key]);
+}
+/** The open keys after OPENING `key` (find-in-page, selecting into a closed panel). */
+function openAccordionItem(open, key, behaviour) {
+    return open.has(key) ? new Set(open) : nextAccordionState(open, key, behaviour);
+}
+var AccordionKeyAction;
+(function (AccordionKeyAction) {
+    AccordionKeyAction["Next"] = "next";
+    AccordionKeyAction["Previous"] = "previous";
+    AccordionKeyAction["First"] = "first";
+    AccordionKeyAction["Last"] = "last";
+})(AccordionKeyAction || (AccordionKeyAction = {}));
+/** The APG accordion's keys on a header: ↓ ↑ move (and wrap), Home / End jump. Enter and Space are the
+ *  button's own. */
+const KEY_ACTIONS = {
+    ArrowDown: AccordionKeyAction.Next,
+    ArrowUp: AccordionKeyAction.Previous,
+    Home: AccordionKeyAction.First,
+    End: AccordionKeyAction.Last,
+};
+function accordionKeyAction(key) {
+    return KEY_ACTIONS[key] ?? null;
+}
+/** The header index `action` moves focus to, from `current` among `count` headers (↓ ↑ wrap). */
+function accordionFocusIndex(action, current, count) {
+    if (count <= 0)
+        return -1;
+    switch (action) {
+        case AccordionKeyAction.Next: return (current + 1) % count;
+        case AccordionKeyAction.Previous: return (current - 1 + count) % count;
+        case AccordionKeyAction.First: return 0;
+        case AccordionKeyAction.Last: return count - 1;
+    }
+}
+// ── identity, ids and attributes (both renderers, SSR included) ────────────────────────────────
+/** A key safe in an element id. */
+function domSafeKey(raw) {
+    return String(raw ?? '').replace(/[^A-Za-z0-9_-]/g, '-');
+}
+/** A content row's identity: its own id (never its index — a reorder in the CMS must never pair a header with
+ *  another row's panel, R3); the index only for a row that has none. */
+function rowItemKey(row, index) {
+    const r = row;
+    const id = r && typeof r === 'object' ? (r._id ?? r.id) : undefined;
+    return id !== undefined && id !== null && id !== '' ? domSafeKey(id) : `row-${index}`;
+}
+/** The ARIA pairing ids of an item: unique per accordion (its root's node id) and per item (its key). */
+function accordionDomIds(rootId, itemKey) {
+    const base = `iox-acc-${domSafeKey(rootId)}-${domSafeKey(itemKey)}`;
+    return { trigger: `${base}-h`, panel: `${base}-p` };
+}
+function accordionScope(rootId, behaviour, keys) {
+    return { rootId, behaviour, keys, open: initialAccordionOpen(keys, behaviour.defaultOn) };
+}
+function accordionItemState(scope, index) {
+    const key = scope.keys[index] ?? `item-${index}`;
+    return { key, index, on: scope.open.has(key), ids: accordionDomIds(scope.rootId, key) };
+}
+/** `data-iox-on` — the ONE attribute every "on" style keys on (Open, Item open). */
+const ON_ATTRIBUTE = 'data-iox-on';
+const ITEM_KEY_ATTRIBUTE = 'data-iox-item-key';
+const COMPOSITE_ATTRIBUTE = 'data-iox-composite';
+const MULTIPLE_ATTRIBUTE = 'data-iox-multiple';
+const DEFAULT_ON_ATTRIBUTE = 'data-iox-default-on';
+/** The value a closed panel's region carries: find-in-page can still reveal it (D9, board 4). */
+const UNTIL_FOUND = 'until-found';
+/** The structural classes the renderers write around an accordion's parts (no node owns them). */
+var AccordionClass;
+(function (AccordionClass) {
+    AccordionClass["Heading"] = "iox-accordion-heading";
+    AccordionClass["Button"] = "iox-accordion-button";
+    AccordionClass["Track"] = "iox-accordion-track";
+    AccordionClass["Region"] = "iox-accordion-region";
+})(AccordionClass || (AccordionClass = {}));
+function accordionRootAttributes(behaviour) {
+    return {
+        [COMPOSITE_ATTRIBUTE]: AccordionRole.Accordion,
+        [DEFAULT_ON_ATTRIBUTE]: behaviour.defaultOn,
+        ...(behaviour.multiple ? { [MULTIPLE_ATTRIBUTE]: '' } : {}),
+    };
+}
+function accordionItemAttributes(state) {
+    return { [ITEM_KEY_ATTRIBUTE]: state.key, ...(state.on ? { [ON_ATTRIBUTE]: '' } : {}) };
+}
+function accordionTriggerAttributes(state) {
+    return {
+        type: 'button',
+        id: state.ids.trigger,
+        'aria-expanded': state.on ? 'true' : 'false',
+        'aria-controls': state.ids.panel,
+        ...(state.on ? { [ON_ATTRIBUTE]: '' } : {}),
+    };
+}
+/** The track wrapping a panel: its row collapses to 0 while closed (the ONE hiding rule, iox-design.css). */
+function accordionTrackAttributes(state) {
+    return state.on ? { [ON_ATTRIBUTE]: '' } : {};
+}
+/** The region the panel sits in: `hidden="until-found"` while closed, so its words stay in the page. */
+function accordionRegionAttributes(state) {
+    return {
+        role: 'region',
+        id: state.ids.panel,
+        'aria-labelledby': state.ids.trigger,
+        ...(state.on ? {} : { hidden: UNTIL_FOUND }),
+    };
+}
+function accordionPanelAttributes(state) {
+    return state.on ? { [ON_ATTRIBUTE]: '' } : {};
+}
+/** `attrs` as an HTML attribute string (` a="b" c`), values escaped by `esc`. */
+function serializeDomAttributes(attrs, esc) {
+    return Object.entries(attrs).map(([k, v]) => (v === '' ? ` ${k}` : ` ${k}="${esc(v)}"`)).join('');
+}
+const SHORT_TEXT = new Set(['text']);
+const LONG_TEXT = new Set(['textarea', 'richText', 'editor']);
+/** R3 (board 9 Q19): switching to From content binds the question to the first short-text field and the
+ *  answer to the first long-text field. ONE rule for the builder's switch and the composer. */
+function pickAccordionAutoBinds(fields) {
+    const isString = (f) => !f.type || f.type === 'string';
+    const question = fields.find(f => isString(f) && SHORT_TEXT.has(String(f.controller ?? 'text')))?.name ?? null;
+    const answer = fields.find(f => isString(f) && LONG_TEXT.has(String(f.controller ?? '')) && f.name !== question)?.name ?? null;
+    return { question, answer };
+}
+/** The bound props of the question and the answer (each a content trait). */
+const ACCORDION_BIND_PROP = 'content';
+/**
+ * Manual → From content (board 9 "Items: Manual · From content"): the root becomes `repeater` (a Repeater node
+ * the caller created with the same id, role, label, element style and styles — a type change is the
+ * consumer's), the FIRST item becomes the one template (its parts, styles and interactions kept; its key
+ * dropped — a row's key is its id) and the others are removed. Returns the removed items.
+ */
+function accordionToContent(root, repeater) {
+    const items = accordionItems(root);
+    const [template, ...rest] = items;
+    if (template)
+        delete template.itemKey;
+    repeater.role = AccordionRole.Accordion;
+    repeater.children = template ? [template] : [];
+    writeProp(repeater, CompositeBehaviourTrait.Multiple, accordionBehaviour(root).multiple);
+    writeProp(repeater, CompositeBehaviourTrait.DefaultOn, accordionBehaviour(root).defaultOn);
+    return rest;
+}
+/**
+ * From content → Manual: the rows come in as static items — each a copy of the template (`cloneItem`, which
+ * gives the copy fresh ids) whose bound words are written in as its own and whose bindings are dropped.
+ * `container` is the manual root the caller created. Returns the new items.
+ */
+function accordionToManual(root, container, rows, cloneItem, resolve) {
+    const template = accordionItems(root)[0];
+    container.role = AccordionRole.Accordion;
+    writeProp(container, CompositeBehaviourTrait.Multiple, accordionBehaviour(root).multiple);
+    writeProp(container, CompositeBehaviourTrait.DefaultOn, accordionBehaviour(root).defaultOn);
+    const items = template ? rows.map((row, i) => {
+        const item = cloneItem(template);
+        item.itemKey = `k${i + 1}`;
+        walkComposite(item, n => {
+            const bindings = n.bindings ?? [];
+            for (const b of bindings) {
+                const value = resolve(row, b);
+                if (value !== undefined && value !== null)
+                    writeProp(n, b.prop, value);
+            }
+            if (bindings.length)
+                n.bindings = [];
+        });
+        return item;
+    }) : [];
+    container.children = items;
+    return items;
+}
+/** The style a part holds for `name` (both node shapes) — exported for the consumers' detectors. */
+function accordionPartStyle(node, name) {
+    return readOwnedTrait(node, { trait: name });
+}
+
+/**
+ * The Accordion's RUNTIME (CC2) — ONE copy, DOM only, for the builder canvas and the live site (both engine
+ * paths render the same markup). It reads the markup the renderers write (iox-design.css + accordion.ts's
+ * attribute planners), so the server's first paint and every later state agree:
+ *
+ *   [root]  data-iox-composite="accordion"  data-iox-default-on  [data-iox-multiple]   (the node's own element —
+ *           its role class may sit on a wrapper host, as the engine's component-path Repeater draws it)
+ *     .iox-role-accordion-item  data-iox-item-key  [data-iox-on]
+ *       hN.iox-accordion-heading > button.iox-accordion-button  id  aria-expanded  aria-controls
+ *       .iox-accordion-track [data-iox-on] > .iox-accordion-region  role=region  [hidden=until-found]
+ *         .iox-role-accordion-panel
+ *
+ * It owns: a click on a header toggles its item; ↓ ↑ Home End move between the headers of THIS accordion
+ * (a nested one keeps its own); find-in-page (`beforematch`) opens the item that holds the match; a closed
+ * panel gets `hidden="until-found"` after its track has collapsed (at once under reduced motion). Every
+ * change dispatches `iox-item-on` / `iox-item-off` on the item, the `itemOn` / `itemOff` interaction
+ * triggers. The open set is LIVE ∪ FORCED: the builder forces items open (a selection inside a closed panel,
+ * "All open"); the live site forces nothing.
+ */
+const ITEM_ON_EVENT = 'iox-item-on';
+const ITEM_OFF_EVENT = 'iox-item-off';
+const ROOT_SELECTOR = `[${COMPOSITE_ATTRIBUTE}="${AccordionRole.Accordion}"]`;
+const ITEM_SELECTOR = '.iox-role-accordion-item';
+const PANEL_SELECTOR = '.iox-role-accordion-panel';
+const BUTTON_SELECTOR = `.${AccordionClass.Button}`;
+const TRACK_SELECTOR = `.${AccordionClass.Track}`;
+const REGION_SELECTOR = `.${AccordionClass.Region}`;
+/** How long a closing track may take before its region is hidden (dur-base is 200–320ms in every pack). */
+const MAX_CLOSE_MS = 600;
+const REDUCED_MOTION = '(prefers-reduced-motion: reduce)';
+/** The accordion an element belongs to (the element itself when it is a root). */
+function closestAccordion(el) {
+    return el?.closest?.(ROOT_SELECTOR) ?? null;
+}
+/** The item an element sits in (itself when it is one). */
+function closestAccordionItem(el) {
+    return el?.closest?.(ITEM_SELECTOR) ?? null;
+}
+/** Subscribe to an item turning on / off — what the `itemOn` / `itemOff` interaction triggers listen to. The
+ *  item is the element's own item (the element itself when it is one). Returns the unsubscribe. */
+function onAccordionItemState(el, on, handler) {
+    const item = closestAccordionItem(el);
+    if (!item)
+        return () => undefined;
+    const type = on ? ITEM_ON_EVENT : ITEM_OFF_EVENT;
+    item.addEventListener(type, handler);
+    return () => item.removeEventListener(type, handler);
+}
+/** True when the element's item is open now. */
+function isAccordionItemOn(el) {
+    return !!closestAccordionItem(el)?.hasAttribute(ON_ATTRIBUTE);
+}
+const nodeIdOf = (el) => {
+    for (const c of Array.from(el.classList))
+        if (c.startsWith('iox-node-'))
+            return c.slice('iox-node-'.length);
+    return '';
+};
+function behaviourOf(root) {
+    const raw = root.getAttribute(DEFAULT_ON_ATTRIBUTE);
+    return {
+        multiple: root.hasAttribute(MULTIPLE_ATTRIBUTE),
+        defaultOn: ACCORDION_DEFAULT_ONS.includes(raw) ? raw : AccordionDefaultOn.First,
+    };
+}
+function setAttr(el, name, value) {
+    if (!el)
+        return;
+    if (value === null) {
+        if (el.hasAttribute(name))
+            el.removeAttribute(name);
+    }
+    else if (el.getAttribute(name) !== value)
+        el.setAttribute(name, value);
+}
+class AccordionRuntime {
+    constructor(root, options = {}) {
+        this.root = root;
+        this.options = options;
+        this.shown = new Set();
+        this.closing = new Map();
+        this.observer = null;
+        this.stampQueued = false;
+        /** The builder attaches a root before its items render: the saved default is applied once they do. */
+        this.awaitingItems = false;
+        this.onClick = (event) => {
+            const button = event.target?.closest?.(BUTTON_SELECTOR);
+            if (!button || closestAccordion(button) !== this.root)
+                return;
+            const item = closestAccordionItem(button);
+            if (!item)
+                return;
+            event.preventDefault();
+            this.toggle(this.keyOf(item));
+        };
+        this.onKeydown = (event) => {
+            const e = event;
+            const action = accordionKeyAction(e.key);
+            const button = e.target?.closest?.(BUTTON_SELECTOR);
+            if (!action || !button || closestAccordion(button) !== this.root)
+                return;
+            const buttons = this.buttons();
+            const at = buttons.indexOf(button);
+            const target = buttons[accordionFocusIndex(action, at, buttons.length)];
+            if (!target)
+                return;
+            e.preventDefault();
+            target.focus();
+        };
+        this.onBeforeMatch = (event) => {
+            const region = event.target?.closest?.(REGION_SELECTOR);
+            const item = closestAccordionItem(region);
+            if (!item || closestAccordion(item.parentElement) !== this.root)
+                return;
+            this.open(this.keyOf(item));
+        };
+        this.behaviourValue = options.behaviour ?? behaviourOf(root);
+        root.setAttribute(COMPOSITE_ATTRIBUTE, AccordionRole.Accordion);
+        // The server rendered the first state; with no server state the root's default decides.
+        // (The builder passes the behaviour and starts from the saved default; on the live site the server
+        // stamped every item's key and state, and that is the truth.)
+        const items = this.items();
+        const serverStamped = !options.behaviour && items.some(i => i.hasAttribute(ITEM_KEY_ATTRIBUTE));
+        this.live = serverStamped
+            ? new Set(items.filter(i => i.hasAttribute(ON_ATTRIBUTE)).map(i => this.keyOf(i, items)))
+            : initialAccordionOpen(items.map(i => this.keyOf(i, items)), this.behaviourValue.defaultOn);
+        this.awaitingItems = !serverStamped && !items.length;
+        this.shown = new Set(this.live);
+        // Capture: on the builder canvas every part's own listener stops the click (it selects that part), and
+        // the header must still toggle — the canvas is a live runtime.
+        root.addEventListener('click', this.onClick, true);
+        root.addEventListener('keydown', this.onKeydown);
+        root.addEventListener('beforematch', this.onBeforeMatch, true);
+        if (options.observe && typeof MutationObserver !== 'undefined') {
+            this.observer = new MutationObserver(() => this.queueStamp());
+            this.observer.observe(root, { childList: true, subtree: true });
+        }
+        this.stamp(true);
+    }
+    get behaviour() {
+        return this.behaviourValue;
+    }
+    /** The behaviour changed in the panel: re-read, and start from the new default. */
+    setBehaviour(behaviour) {
+        const changedDefault = behaviour.defaultOn !== this.behaviourValue.defaultOn;
+        this.behaviourValue = behaviour;
+        if (behaviour.multiple)
+            this.root.setAttribute(MULTIPLE_ATTRIBUTE, '');
+        else
+            this.root.removeAttribute(MULTIPLE_ATTRIBUTE);
+        this.root.setAttribute(DEFAULT_ON_ATTRIBUTE, behaviour.defaultOn);
+        if (changedDefault)
+            this.resetLive();
+        else
+            this.stamp();
+    }
+    /** THIS accordion's items, in document order (a nested accordion's items are its own). */
+    items() {
+        return Array.from(this.root.querySelectorAll(ITEM_SELECTOR)).filter(i => closestAccordion(i.parentElement) === this.root);
+    }
+    /** The open keys the live state holds (before anything forced). */
+    get liveKeys() {
+        return this.live;
+    }
+    /** The keys showing open right now. */
+    get openKeys() {
+        return this.shown;
+    }
+    keyOf(item, items = this.items()) {
+        return item.getAttribute(ITEM_KEY_ATTRIBUTE) || `item-${items.indexOf(item)}`;
+    }
+    toggle(key) {
+        this.live = nextAccordionState(this.live, key, this.behaviourValue);
+        this.stamp();
+    }
+    open(key) {
+        this.live = openAccordionItem(this.live, key, this.behaviourValue);
+        this.stamp();
+    }
+    /** Back to the saved default ("Showing on canvas ▸ As saved"). */
+    resetLive() {
+        const items = this.items();
+        this.live = initialAccordionOpen(items.map(i => this.keyOf(i, items)), this.behaviourValue.defaultOn);
+        this.stamp();
+    }
+    /** The forced set changed (builder design state): show it. */
+    refresh() {
+        this.stamp();
+    }
+    destroy() {
+        this.root.removeEventListener('click', this.onClick, true);
+        this.root.removeEventListener('keydown', this.onKeydown);
+        this.root.removeEventListener('beforematch', this.onBeforeMatch, true);
+        this.observer?.disconnect();
+        this.observer = null;
+        for (const t of this.closing.values())
+            clearTimeout(t);
+        this.closing.clear();
+    }
+    queueStamp() {
+        if (this.stampQueued)
+            return;
+        this.stampQueued = true;
+        const run = () => { this.stampQueued = false; this.stamp(); };
+        if (typeof queueMicrotask === 'function')
+            queueMicrotask(run);
+        else
+            Promise.resolve().then(run);
+    }
+    reduced() {
+        if (this.options.reducedMotion)
+            return this.options.reducedMotion();
+        try {
+            return typeof matchMedia === 'function' && matchMedia(REDUCED_MOTION).matches;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Write every item's state into its markup; announce what changed. */
+    stamp(first = false) {
+        // Our own writes must not wake the observer (they are attributes; it watches the child lists only).
+        const items = this.items();
+        if (this.awaitingItems && items.length) {
+            this.awaitingItems = false;
+            this.live = initialAccordionOpen(items.map(i => this.keyOf(i, items)), this.behaviourValue.defaultOn);
+            first = true;
+        }
+        const forced = this.options.forced?.() ?? new Set();
+        const rootId = this.options.rootId ?? nodeIdOf(this.root);
+        const next = new Set();
+        items.forEach((item, index) => {
+            const key = this.keyOf(item, items);
+            const on = this.live.has(key) || forced.has(key);
+            if (on)
+                next.add(key);
+            this.stampItem(item, key, index, on, rootId, first);
+        });
+        const was = first ? new Set() : this.shown;
+        this.shown = next;
+        // On the first stamp an item open by default HAS opened: its `itemOn` listeners attached so far hear it
+        // (the builder renders an item's parts, and attaches their interactions, before its root's runtime; the
+        // live engine attaches the runtime first and its interactions run an already-open item's at once).
+        for (const item of items) {
+            const key = this.keyOf(item, items);
+            if (next.has(key) && !was.has(key))
+                dispatch(item, ITEM_ON_EVENT);
+            else if (!next.has(key) && was.has(key))
+                dispatch(item, ITEM_OFF_EVENT);
+        }
+    }
+    stampItem(item, key, index, on, rootId, first) {
+        const ids = accordionDomIds(rootId, key);
+        if (!item.hasAttribute(ITEM_KEY_ATTRIBUTE))
+            item.setAttribute(ITEM_KEY_ATTRIBUTE, key);
+        setAttr(item, ON_ATTRIBUTE, on ? '' : null);
+        const button = this.own(item, BUTTON_SELECTOR);
+        const track = this.own(item, TRACK_SELECTOR);
+        const region = this.own(item, REGION_SELECTOR);
+        const panel = this.own(item, PANEL_SELECTOR);
+        setAttr(button, 'type', 'button');
+        setAttr(button, 'id', ids.trigger);
+        setAttr(button, 'aria-expanded', on ? 'true' : 'false');
+        setAttr(button, 'aria-controls', ids.panel);
+        setAttr(button, ON_ATTRIBUTE, on ? '' : null);
+        setAttr(track, ON_ATTRIBUTE, on ? '' : null);
+        setAttr(panel, ON_ATTRIBUTE, on ? '' : null);
+        setAttr(region, 'role', 'region');
+        setAttr(region, 'id', ids.panel);
+        setAttr(region, 'aria-labelledby', ids.trigger);
+        if (!region)
+            return;
+        const pending = this.closing.get(key);
+        if (on) {
+            if (pending) {
+                clearTimeout(pending);
+                this.closing.delete(key);
+            }
+            setAttr(region, 'hidden', null);
+            return;
+        }
+        if (region.hasAttribute('hidden') || pending)
+            return;
+        // Closing: the track collapses first (its transition), THEN the region is hidden — hiding it at once
+        // would collapse it with no motion. At first paint, or under reduced motion, it is hidden at once.
+        if (first || this.reduced()) {
+            setAttr(region, 'hidden', UNTIL_FOUND);
+            return;
+        }
+        const hide = () => {
+            this.closing.delete(key);
+            if (!item.hasAttribute(ON_ATTRIBUTE))
+                setAttr(region, 'hidden', UNTIL_FOUND);
+        };
+        this.closing.set(key, setTimeout(hide, this.closeDelay(track)));
+    }
+    closeDelay(track) {
+        try {
+            const view = track?.ownerDocument?.defaultView;
+            const raw = track && view ? view.getComputedStyle(track).transitionDuration : '';
+            const ms = Math.max(0, ...String(raw).split(',').map(s => (s.trim().endsWith('ms') ? parseFloat(s) : parseFloat(s) * 1000)).filter(n => !isNaN(n)));
+            return Math.min(MAX_CLOSE_MS, ms + 20);
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** The element `selector` matches inside `item` that belongs to it, not to an item nested in it. */
+    own(item, selector) {
+        return Array.from(item.querySelectorAll(selector)).find(el => closestAccordionItem(el) === item) ?? null;
+    }
+    buttons() {
+        return this.items().map(i => this.own(i, BUTTON_SELECTOR)).filter((b) => !!b);
+    }
+}
+function dispatch(el, type) {
+    const Ctor = globalThis.CustomEvent;
+    if (Ctor)
+        el.dispatchEvent(new Ctor(type, { bubbles: false }));
+}
+/** Attach the runtime to one rendered accordion root, unless it already runs one. Returns the NEW runtime, or
+ *  null when the root already had one (so a caller destroys only what it created). */
+function attachAccordionAt(root, options = {}) {
+    if (ATTACHED.has(root))
+        return null;
+    const runtime = new AccordionRuntime(root, options);
+    ATTACHED.set(root, runtime);
+    return runtime;
+}
+/** Attach the runtime to every accordion under `container` that has none yet. Returns the new runtimes. */
+function attachAccordions(container, options = {}) {
+    const out = [];
+    container.querySelectorAll(ROOT_SELECTOR).forEach(root => {
+        const runtime = attachAccordionAt(root, options);
+        if (runtime)
+            out.push(runtime);
+    });
+    return out;
+}
+/** Detach a runtime `attachAccordions` created. */
+function detachAccordion(runtime) {
+    runtime.destroy();
+    ATTACHED.delete(runtime.root);
+}
+const ATTACHED = new WeakMap();
+
 /**
  * BADGE + CHIP (composite T25; complex-components board 8). A Badge is a Container wearing
  * `badge-<tone>` › Icon + Text; its TONE is its element style, so Badge ▸ Tone writes the style and
@@ -656,6 +1546,12 @@ const COMPOSITE_ROLE_SPECS = {
     [CardRole.Title]: { parent: CardRole.Content, locked: true },
     [CardRole.Text]: { parent: CardRole.Content, part: CardPart.Text },
     [CardRole.Actions]: { parent: CardRole.Content, part: CardPart.Actions },
+    // CC2 — an item always keeps its header and its panel; the icon is Behaviour ▸ Icon's.
+    [AccordionRole.Accordion]: { parent: null },
+    [AccordionRole.Item]: { parent: AccordionRole.Accordion },
+    [AccordionRole.Trigger]: { parent: AccordionRole.Item, locked: true },
+    [AccordionRole.Panel]: { parent: AccordionRole.Item, locked: true },
+    [AccordionRole.Icon]: { parent: AccordionRole.Trigger },
 };
 var StructureEdit;
 (function (StructureEdit) {
@@ -693,7 +1589,8 @@ function isLockedPart(node) {
  * @vectoriox/iox-ui/composite-core — composites built from the builder's own parts (composite-components
  * plan §3a). FRAMEWORK-FREE: the builder, the SSR engine and iox-cms (generation-core's composer, the site
  * build) read the same recipes, roles and structure rules. Card v2 + Badge / Chip (T23 / T25) are the
- * first; Accordion and Tabs join with their own phases.
+ * first; the Accordion (CC2) adds the first composite RUNTIME (accordion-runtime.ts — DOM only, no
+ * framework); Tabs join with their own phase.
  * ⚠️ Consumers wire the usual trio — ng-package raw-ts assets, jest moduleNameMapper, tsconfig paths.
  */
 
@@ -701,5 +1598,5 @@ function isLockedPart(node) {
  * Generated bundle index. Do not edit.
  */
 
-export { BADGE_TONES, BADGE_TONE_ICONS, BadgeTone, CARD_LAYOUTS, CARD_LAYOUT_CUSTOM, CARD_PARTS, CARD_PART_ROLE, CARD_STACK_BREAKPOINT, CARD_WORDS, CHIP_ICON, CHIP_STYLE, COMPOSITE_ROLE_SPECS, CardLayout, CardPart, CardRole, PILL_LABEL_STYLE, StructureEdit, StructureRefusal, applyCardLayout, badgeStyleId, badgeToneOf, buildBadge, buildCardRecipe, buildChip, cardPartsOf, cardRootOf, cardTitleOf, clearLayerStyles, detectCardLayout, findByRole, isCardLinked, isCardRoot, isLockedPart, isPillNode, parentInComposite, readLayerStyle, readProp, readStyle, removeFromComposite, setBadgeTone, setCardLinked, setCardPart, structureRefusal, walkComposite, writeLayerStyles, writeProp, writeStyles };
+export { ACCORDION_BIND_PROP, ACCORDION_CONTENT_LIMIT, ACCORDION_DEFAULT_ONS, ACCORDION_ICONS, ACCORDION_ICON_GLYPH, ACCORDION_NEW_ITEM_WORDS, ACCORDION_WORDS, AccordionClass, AccordionDefaultOn, AccordionEditRefusal, AccordionIcon, AccordionKeyAction, AccordionRole, AccordionRuntime, BADGE_TONES, BADGE_TONE_ICONS, BadgeTone, CARD_LAYOUTS, CARD_LAYOUT_CUSTOM, CARD_PARTS, CARD_PART_ROLE, CARD_STACK_BREAKPOINT, CARD_WORDS, CHIP_ICON, CHIP_STYLE, COMPOSITE_ATTRIBUTE, COMPOSITE_ROLE_SPECS, CardLayout, CardPart, CardRole, CompositeBehaviourTrait, DEFAULT_ON_ATTRIBUTE, ITEM_KEY_ATTRIBUTE, ITEM_OFF_EVENT, ITEM_ON_EVENT, ITEM_OPEN_STATE, MULTIPLE_ATTRIBUTE, ON_ATTRIBUTE, ON_STATE, PILL_LABEL_STYLE, StructureEdit, StructureRefusal, UNTIL_FOUND, accordionAnswerOf, accordionBehaviour, accordionDomIds, accordionFocusIndex, accordionHeadingLevel, accordionItemAttributes, accordionItemLabel, accordionItemOf, accordionItemState, accordionItems, accordionKeyAction, accordionPanelAttributes, accordionPanelOf, accordionPartStyle, accordionQuestionOf, accordionRegionAttributes, accordionRemovalRefusal, accordionRootAttributes, accordionRootOf, accordionScope, accordionToContent, accordionToManual, accordionTrackAttributes, accordionTriggerAttributes, accordionTriggerOf, addAccordionItem, applyCardLayout, attachAccordionAt, attachAccordions, badgeStyleId, badgeToneOf, buildAccordionItem, buildAccordionRecipe, buildBadge, buildCardRecipe, buildChip, cardPartsOf, cardRootOf, cardTitleOf, clearLayerStyles, closestAccordion, closestAccordionItem, detachAccordion, detectAccordionIcon, detectCardLayout, domSafeKey, findByRole, initialAccordionOpen, isAccordionFromContent, isAccordionItemOn, isAccordionPart, isAccordionRoot, isCardLinked, isCardRoot, isLockedPart, isPillNode, itemOpenTriggerIds, moveAccordionItem, nextAccordionState, nextItemKey, onAccordionItemState, openAccordionItem, parentInComposite, pickAccordionAutoBinds, readLayerStyle, readProp, readStyle, removeFromComposite, renameAccordionItem, rowItemKey, serializeDomAttributes, setAccordionBehaviour, setAccordionIcon, setBadgeTone, setCardLinked, setCardPart, structureRefusal, walkComposite, writeLayerStyles, writeProp, writeStyles };
 //# sourceMappingURL=vectoriox-iox-ui-composite-core.mjs.map