@oscharko-dev/keiko-quality-intelligence 0.2.0

package/dist/domain/figma/normalize.js

@@ -0,0 +1,252 @@
+// Per-node normalization of the pruned tree into IR nodes (Epic #750, Issue #752).
+//
+// Projects each kept node to a compact `IrNode`: id/name/type, text content, bounding box, image
+// fill refs, kept children, and a best-effort `interactionHint`.
+//
+// In addition to the structural fields, five additive optional fields are projected when present:
+//   layout     — auto-layout direction/gap/padding/alignment (HORIZONTAL/VERTICAL layoutMode)
+//   sizing     — per-axis sizing mode (layoutSizingHorizontal/Vertical: FIXED|HUG|FILL)
+//   cornerRadius — corner radius in pixels (cornerRadius > 0)
+//   typography — per-TEXT fontFamily/fontSize/fontWeight (from the `style` block)
+//
+// These fields are OMITTED when absent or when the source values are missing/malformed — never
+// defaulted. They are hash-neutral (#753/#735): re-normalizing the same structural design after
+// these fields ship does not change the drift identity. Negative, NaN, and non-finite values are
+// clamped to absent.
+//
+// The interaction hint is a HINT, never load-bearing — downstream (#754) treats button/input
+// classification as advisory and degrades to `container`. Three classes are purely structural:
+//   link  — the node carries a navigating prototype interaction/reaction (it navigates).
+//   image — the node has an IMAGE-type fill (and is not TEXT).
+//   text  — the node is a TEXT node.
+// `button` is also used for activation-style local prototype actions (for example ON_CLICK variable
+// updates) because they are interactive controls even when they do not navigate. `button`/`input`
+// name heuristics remain a tiny, word-boundary, case-insensitive match over conventional
+// design-system role vocabulary. Boards that don't use these words and carry no prototype action
+// fall back to `container` — no board's specific names are encoded.
+import { asNode, nodeId, nodeName, nodeType, readArray, readNumber, readString, } from "./sourceNode.js";
+import { firstSolidPaintHex, isVisiblePaint } from "./color.js";
+const BUTTON_ROLE = /\b(?:button|btn|cta)\b/iu;
+const INPUT_ROLE = /\b(?:input|field|textfield|textbox)\b/iu;
+const readBoundingBox = (node) => {
+    const box = asNode(node.absoluteBoundingBox);
+    if (box === undefined)
+        return undefined;
+    const x = readNumber(box.x);
+    const y = readNumber(box.y);
+    const width = readNumber(box.width);
+    const height = readNumber(box.height);
+    if (x === undefined || y === undefined || width === undefined || height === undefined) {
+        return undefined;
+    }
+    return { x, y, width, height };
+};
+const readImageFills = (node) => {
+    const out = [];
+    for (const fill of readArray(node.fills)) {
+        const record = asNode(fill);
+        if (record === undefined || readString(record.type) !== "IMAGE")
+            continue;
+        if (!isVisiblePaint(record))
+            continue;
+        const imageRef = readString(record.imageRef);
+        if (imageRef !== undefined)
+            out.push({ imageRef });
+    }
+    return out;
+};
+const actionHasNavigationTarget = (action) => {
+    const record = asNode(action);
+    if (record === undefined)
+        return false;
+    if (readString(record.destinationId) !== undefined)
+        return true;
+    const nav = asNode(record.navigation);
+    if (nav !== undefined && readString(nav.destinationId) !== undefined)
+        return true;
+    return readString(record.type) === "URL" && readString(record.url) !== undefined;
+};
+const interactionHasNavigationTarget = (entry) => {
+    const record = asNode(entry);
+    if (record === undefined)
+        return false;
+    if (readArray(record.actions).some(actionHasNavigationTarget))
+        return true;
+    return actionHasNavigationTarget(record.action);
+};
+const interactionHasLocalAction = (entry) => {
+    const record = asNode(entry);
+    if (record === undefined)
+        return false;
+    const trigger = asNode(record.trigger);
+    const triggerType = trigger !== undefined ? readString(trigger.type) : undefined;
+    if (triggerType !== "ON_CLICK" && triggerType !== "ON_PRESS" && triggerType !== "ON_TAP") {
+        return false;
+    }
+    return readArray(record.actions).length > 0 || asNode(record.action) !== undefined;
+};
+const navigates = (node) => {
+    const interactions = readArray(node.interactions);
+    const reactions = readArray(node.reactions);
+    return (interactions.some(interactionHasNavigationTarget) ||
+        reactions.some(interactionHasNavigationTarget));
+};
+const hasActivation = (node) => {
+    const interactions = readArray(node.interactions);
+    const reactions = readArray(node.reactions);
+    return interactions.some(interactionHasLocalAction) || reactions.some(interactionHasLocalAction);
+};
+const classify = (node, imageFills) => {
+    if (nodeType(node) === "TEXT")
+        return "text";
+    if (navigates(node))
+        return "link";
+    if (hasActivation(node))
+        return "button";
+    if (imageFills.length > 0)
+        return "image";
+    const name = nodeName(node);
+    if (BUTTON_ROLE.test(name))
+        return "button";
+    if (INPUT_ROLE.test(name))
+        return "input";
+    return "container";
+};
+// A TEXT node's solid fill is its foreground (text) colour; any other node's solid fill is a
+// background. We project at most one of each so the a11y contrast pass (#812) has a deterministic
+// text-vs-background pairing without re-deriving paints. Both are absent when there is no solid fill.
+const readTextColor = (node) => nodeType(node) === "TEXT" ? firstSolidPaintHex(node, "fills") : undefined;
+const readBackgroundColor = (node) => nodeType(node) === "TEXT" ? undefined : firstSolidPaintHex(node, "fills");
+// ─── Layout / sizing / cornerRadius / typography projection ──────────────────
+const ALIGN_MAP = {
+    MIN: "start",
+    CENTER: "center",
+    MAX: "end",
+    SPACE_BETWEEN: "space-between",
+};
+const readAlign = (value) => {
+    const s = readString(value);
+    return s !== undefined ? ALIGN_MAP[s] : undefined;
+};
+const readLayoutMode = (value) => {
+    const s = readString(value);
+    if (s === "HORIZONTAL")
+        return "row";
+    if (s === "VERTICAL")
+        return "column";
+    return undefined;
+};
+const readLayoutSizing = (value) => {
+    const s = readString(value);
+    if (s === "FIXED")
+        return "fixed";
+    if (s === "HUG")
+        return "hug";
+    if (s === "FILL")
+        return "fill";
+    return undefined;
+};
+// A padding value is valid only when it is a finite, non-negative number.
+const readPaddingValue = (value) => {
+    const n = readNumber(value);
+    return n !== undefined && n >= 0 ? n : undefined;
+};
+// Returns [top, right, bottom, left] when at least one side is non-zero; undefined otherwise.
+const readLayoutPadding = (node) => {
+    const top = readPaddingValue(node.paddingTop) ?? 0;
+    const right = readPaddingValue(node.paddingRight) ?? 0;
+    const bottom = readPaddingValue(node.paddingBottom) ?? 0;
+    const left = readPaddingValue(node.paddingLeft) ?? 0;
+    return top > 0 || right > 0 || bottom > 0 || left > 0 ? [top, right, bottom, left] : undefined;
+};
+const readLayout = (node) => {
+    const mode = readLayoutMode(node.layoutMode);
+    if (mode === undefined)
+        return undefined;
+    const itemSpacing = readNumber(node.itemSpacing);
+    const padding = readLayoutPadding(node);
+    const primaryAlign = readAlign(node.primaryAxisAlignItems);
+    const counterAlign = readAlign(node.counterAxisAlignItems);
+    return {
+        mode,
+        ...(itemSpacing !== undefined && itemSpacing > 0 ? { itemSpacing } : {}),
+        ...(padding !== undefined ? { padding } : {}),
+        ...(primaryAlign !== undefined ? { primaryAlign } : {}),
+        ...(counterAlign !== undefined ? { counterAlign } : {}),
+    };
+};
+const readSizing = (node) => {
+    const horizontal = readLayoutSizing(node.layoutSizingHorizontal);
+    const vertical = readLayoutSizing(node.layoutSizingVertical);
+    if (horizontal === undefined && vertical === undefined)
+        return undefined;
+    return {
+        ...(horizontal !== undefined ? { horizontal } : {}),
+        ...(vertical !== undefined ? { vertical } : {}),
+    };
+};
+const readCornerRadius = (node) => {
+    const value = readNumber(node.cornerRadius);
+    return value !== undefined && value > 0 ? value : undefined;
+};
+const readTypography = (node) => {
+    if (nodeType(node) !== "TEXT")
+        return undefined;
+    const style = asNode(node.style);
+    if (style === undefined)
+        return undefined;
+    const fontFamily = readString(style.fontFamily);
+    const fontSize = readNumber(style.fontSize);
+    const fontWeight = readNumber(style.fontWeight);
+    const lineHeight = readNumber(style.lineHeightPx);
+    if (fontFamily === undefined || fontSize === undefined || fontWeight === undefined)
+        return undefined;
+    return {
+        fontFamily,
+        fontSize,
+        fontWeight,
+        ...(lineHeight !== undefined ? { lineHeight } : {}),
+    };
+};
+// Subtrees deeper than this are truncated to prevent RangeError on malformed chain-like inputs.
+// Same shared constant as prune.ts — see there for the rationale. Must stay in sync with every
+// other recursive walk in this pipeline (tokens, links, a11y, screenIrTestBaseline).
+const MAX_TREE_DEPTH = 512;
+function buildNodeAt(pruned, depth) {
+    const node = pruned.source;
+    const imageFills = readImageFills(node);
+    const text = readString(node.characters);
+    const boundingBox = readBoundingBox(node);
+    const textColor = readTextColor(node);
+    const backgroundColor = readBackgroundColor(node);
+    const children = depth >= MAX_TREE_DEPTH ? [] : pruned.children.map((c) => buildNodeAt(c, depth + 1));
+    const layout = readLayout(node);
+    const sizing = readSizing(node);
+    const cornerRadius = readCornerRadius(node);
+    const typography = readTypography(node);
+    return {
+        id: nodeId(node),
+        name: nodeName(node),
+        type: nodeType(node),
+        interactionHint: classify(node, imageFills),
+        ...(text !== undefined ? { text } : {}),
+        ...(boundingBox !== undefined ? { boundingBox } : {}),
+        ...(textColor !== undefined ? { textColor } : {}),
+        ...(backgroundColor !== undefined ? { backgroundColor } : {}),
+        ...(layout !== undefined ? { layout } : {}),
+        ...(sizing !== undefined ? { sizing } : {}),
+        ...(cornerRadius !== undefined ? { cornerRadius } : {}),
+        ...(typography !== undefined ? { typography } : {}),
+        imageFills,
+        children,
+    };
+}
+/** Normalize a pruned screen root into its IR node tree. Child order follows source order. */
+export const normalizeScreenRoot = (pruned) => buildNodeAt(pruned, 0);
+function countIrNodesAt(node, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return 1;
+    return 1 + node.children.reduce((sum, child) => sum + countIrNodesAt(child, depth + 1), 0);
+}
+/** Count the IR nodes in a normalized tree, used for the reduction ratio. */
+export const countIrNodes = (node) => countIrNodesAt(node, 0);

package/dist/domain/figma/prune.d.ts

@@ -0,0 +1,15 @@
+import { type FigmaSourceNode } from "./sourceNode.js";
+/** A node that survived pruning, paired with its pruned children. */
+export interface PrunedNode {
+    readonly source: FigmaSourceNode;
+    readonly children: readonly PrunedNode[];
+}
+/**
+ * Prune a node, returning the kept node (with kept children) or `undefined` when the node itself is
+ * dropped. A node is dropped when hidden, a component master, or an empty scaffold. Subtrees deeper
+ * than MAX_TREE_DEPTH are truncated so malformed chain-like inputs degrade rather than overflow.
+ */
+export declare const pruneNode: (node: FigmaSourceNode) => PrunedNode | undefined;
+/** Total node count of a raw subtree (root included), used for the reduction ratio. */
+export declare const countSourceNodes: (node: FigmaSourceNode) => number;
+//# sourceMappingURL=prune.d.ts.map

package/dist/domain/figma/prune.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/prune.ts"],"names":[],"mappings":"AAaA,OAAO,EAOL,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAazB,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AA0BD;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,eAAe,KAAG,UAAU,GAAG,SAAiC,CAAC;AASjG,uFAAuF;AACvF,eAAO,MAAM,gBAAgB,GAAI,MAAM,eAAe,KAAG,MAAqC,CAAC"}

package/dist/domain/figma/prune.js

@@ -0,0 +1,65 @@
+// Deterministic pruning of the raw Figma node subtree (Epic #750, Issue #752).
+//
+// Three structural drop rules, justified without any board-specific tuning:
+//   1. `visible === false`  — the node is explicitly hidden in Figma; the whole subtree is dropped.
+//   2. type COMPONENT / COMPONENT_SET — design-system definition masters, render-irrelevant. (They
+//      may be absent in an instance-heavy scoped fetch; dropped only when present.) INSTANCE is the
+//      placed, rendered UI and is always kept.
+//   3. empty scaffold — a node with NO render payload (no text, no fills/strokes, no bbox) AND no
+//      kept descendants is a structural marker/wrapper carrying nothing; it is dropped. Anything
+//      with payload or surviving children is kept, so the rule never deletes real UI.
+//
+// Pruning is name-agnostic. No copy, screen name, or component vocabulary participates.
+import { asNode, childNodes, isHidden, nodeType, readArray, readString, } from "./sourceNode.js";
+const MASTER_TYPES = new Set(["COMPONENT", "COMPONENT_SET"]);
+// Subtrees deeper than this are truncated (not walked). Prevents RangeError on malformed inputs with
+// chain-like node trees thousands of levels deep. Documented contract: malformed input degrades, never
+// crashes (cleanToScreenIr.ts header).
+// Shared contract: every recursive tree walk in this pipeline (prune → normalize → tokens → links →
+// a11y → screenIrTestBaseline) uses the same value so that none overflow before the others. 512 is
+// far above any legitimate Figma board depth (< 50 in practice) while staying safe inside vitest
+// worker threads, which have a smaller default JS stack than bare Node.
+const MAX_TREE_DEPTH = 512;
+const hasOwnPayload = (node) => {
+    if (readString(node.characters) !== undefined)
+        return true;
+    if (readArray(node.fills).length > 0)
+        return true;
+    if (readArray(node.strokes).length > 0)
+        return true;
+    if (asNode(node.absoluteBoundingBox) !== undefined)
+        return true;
+    return false;
+};
+const isDroppedByType = (node) => MASTER_TYPES.has(nodeType(node));
+function pruneNodeAt(node, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return undefined;
+    if (isHidden(node) || isDroppedByType(node))
+        return undefined;
+    const children = [];
+    for (const child of childNodes(node)) {
+        const kept = pruneNodeAt(child, depth + 1);
+        if (kept !== undefined)
+            children.push(kept);
+    }
+    if (children.length === 0 && !hasOwnPayload(node))
+        return undefined;
+    return { source: node, children };
+}
+/**
+ * Prune a node, returning the kept node (with kept children) or `undefined` when the node itself is
+ * dropped. A node is dropped when hidden, a component master, or an empty scaffold. Subtrees deeper
+ * than MAX_TREE_DEPTH are truncated so malformed chain-like inputs degrade rather than overflow.
+ */
+export const pruneNode = (node) => pruneNodeAt(node, 0);
+function countSourceNodesAt(node, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return 1; // count the truncated subtree root only
+    let total = 1;
+    for (const child of childNodes(node))
+        total += countSourceNodesAt(child, depth + 1);
+    return total;
+}
+/** Total node count of a raw subtree (root included), used for the reduction ratio. */
+export const countSourceNodes = (node) => countSourceNodesAt(node, 0);

package/dist/domain/figma/screenDetect.d.ts

@@ -0,0 +1,8 @@
+import type { PrunedNode } from "./prune.js";
+/**
+ * Collect the screen roots from a pruned tree. Descends through container nodes (CANVAS/SECTION)
+ * collecting their screen children; does not recurse into screens. A directly-scoped screen root is
+ * returned as the sole screen.
+ */
+export declare const detectScreens: (root: PrunedNode) => readonly PrunedNode[];
+//# sourceMappingURL=screenDetect.d.ts.map

package/dist/domain/figma/screenDetect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenDetect.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/screenDetect.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAS7C;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,UAAU,KAAG,SAAS,UAAU,EAenE,CAAC"}

package/dist/domain/figma/screenDetect.js

@@ -0,0 +1,35 @@
+// Structural screen detection over the pruned Figma subtree (Epic #750, Issue #752).
+//
+// A "screen" is a top-level layout container: a FRAME or INSTANCE that sits directly under the
+// scoped root or under a CANVAS/SECTION container directly beneath it. We descend ONLY through the
+// container types (CANVAS, SECTION) that group screens, never into a screen's own body — so nested
+// frames inside a screen stay part of that screen, not separate screens. If the root itself is a
+// FRAME/INSTANCE (a directly-scoped single screen), it is the one screen. Detection is name-agnostic.
+import { nodeType } from "./sourceNode.js";
+const SCREEN_TYPES = new Set(["FRAME", "INSTANCE"]);
+const CONTAINER_TYPES = new Set(["CANVAS", "SECTION"]);
+const isScreen = (node) => SCREEN_TYPES.has(nodeType(node));
+const isContainer = (node) => CONTAINER_TYPES.has(nodeType(node));
+/**
+ * Collect the screen roots from a pruned tree. Descends through container nodes (CANVAS/SECTION)
+ * collecting their screen children; does not recurse into screens. A directly-scoped screen root is
+ * returned as the sole screen.
+ */
+export const detectScreens = (root) => {
+    if (isScreen(root.source))
+        return [root];
+    if (!isContainer(root.source))
+        return [];
+    const screens = [];
+    for (const child of root.children) {
+        if (isScreen(child.source)) {
+            screens.push(child);
+            continue;
+        }
+        if (isContainer(child.source)) {
+            for (const nested of detectScreens(child))
+                screens.push(nested);
+        }
+    }
+    return screens;
+};

package/dist/domain/figma/screenIrTestBaseline.d.ts

@@ -0,0 +1,52 @@
+import type { ScreenIr } from "./irTypes.js";
+export type StructuralTestCategory = "field-presence" | "field-validation" | "control-action" | "screen-render" | "state" | "navigation" | "flow" | "a11y" | "coverage-notice";
+export type StructuralTestOutcome = "pass" | "fail" | "expectation";
+/** One deterministic, per-screen-attributable test item derived from the Screen-IR. */
+export interface StructuralTestItem {
+    readonly id: string;
+    readonly title: string;
+    readonly category: StructuralTestCategory;
+    /** Optional machine-readable result semantics for derived checks. */
+    readonly outcome?: StructuralTestOutcome;
+    /** Screen provenance so a generated test is attributable to its origin screen. */
+    readonly screenId: string;
+    readonly screenName: string;
+    /** The IR node the item was derived from, when applicable (screen-level items omit it). */
+    readonly sourceNodeId?: string;
+}
+/** The structural baseline for a single screen: ordered, deterministic test items. */
+export interface ScreenTestBaseline {
+    readonly screenId: string;
+    readonly screenName: string;
+    readonly items: readonly StructuralTestItem[];
+}
+export declare const MAX_IR_NODES_PER_SCREEN = 20000;
+/**
+ * Total, defensive Screen-IR parser for the snapshot's opaque `irJson`. Returns `undefined` for a
+ * missing or malformed value (no `root`, malformed node tree) so the caller can skip an unparseable
+ * screen without crashing. A valid IR is returned verbatim through the typed shape.
+ */
+export declare function parseScreenIr(value: unknown): ScreenIr | undefined;
+/**
+ * Derive the deterministic structural baseline for one screen. The screen-render item comes first,
+ * then field / control / state items in stable depth-first node order. `extraItems` is the additive
+ * seam (#811 navigation, #812 a11y): a sibling derivation may contribute already-built test items
+ * for this screen without changing the baseline shape. The result is reproducible for a given IR.
+ */
+export declare function deriveScreenTestBaseline(screen: ScreenIr, extraItems?: readonly StructuralTestItem[]): ScreenTestBaseline;
+/**
+ * Render the structural baseline as citation-ready canonical text carrying per-screen provenance.
+ * The text is deterministic (no timestamps, stable order) and is what the QI ingestion turns into a
+ * content-bearing atom. Vision-derived hints, when present, are appended SEPARATELY by the caller
+ * (visionAugmentation.ts) and never replace these lines.
+ */
+/**
+ * Stable marker line introducing the structural baseline inside a Figma screen atom's canonical text.
+ * Exported so the deterministic test-design model (`testDesignModel.ts`) can recognise a Figma screen
+ * atom and emit a clean, screen-scoped structural candidate instead of the generic prose-requirement
+ * template (which produces an atom-id/hash-laden stub for a structural baseline). Intentionally NOT
+ * re-exported from the figma barrel (`domain/figma/index.ts`), so it stays off the package surface.
+ */
+export declare const STRUCTURAL_BASELINE_MARKER = "Structural test baseline (deterministic, derived from Screen-IR):";
+export declare function renderBaselineText(baseline: ScreenTestBaseline): string;
+//# sourceMappingURL=screenIrTestBaseline.d.ts.map

package/dist/domain/figma/screenIrTestBaseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenIrTestBaseline.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/screenIrTestBaseline.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAuB,QAAQ,EAAE,MAAM,cAAc,CAAC;AAElE,MAAM,MAAM,sBAAsB,GAC9B,gBAAgB,GAChB,kBAAkB,GAClB,gBAAgB,GAChB,eAAe,GACf,OAAO,GAGP,YAAY,GACZ,MAAM,GAGN,MAAM,GACN,iBAAiB,CAAC;AAEtB,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC;AAEpE,uFAAuF;AACvF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,qEAAqE;IACrE,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC;IACzC,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sFAAsF;AACtF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC/C;AA2DD,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAsI9C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAKlE;AA2GD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,QAAQ,EAChB,UAAU,GAAE,SAAS,kBAAkB,EAAO,GAC7C,kBAAkB,CAMpB;AAED;;;;;GAKG;AACH;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,sEAC8B,CAAC;AAEtE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAOvE"}