weasel-icons 0.16.0 → 0.17.0

package/dist/icons/beam-search/beam-search-rig.js

@@ -0,0 +1,88 @@
+/**
+ * A decoding tree read left to right with beam width 2. Idle shows the two beams solid among
+ * faint pruned alternatives. Searching rescoring: the alternatives wither back
+ * toward their parent and stay as cut stubs (while alive they sprout and wither again as
+ * they are rescored). Decoded traces the highest-scoring sequence in accent.
+ */
+export const beamSearchStates = ['idle', 'searching', 'decoded'];
+const NODE = 0.75; // stroked, so the painted node is about 3.15 units across
+/** An edge that ends in its node, one stroke, so withering retracts the node first. */
+const branch = (from, to) => `M${from[0]} ${from[1]}L${to[0] - NODE} ${to[1]}a${NODE} ${NODE} 0 1 0 ${2 * NODE} 0a${NODE} ${NODE} 0 1 0 ${-2 * NODE} 0`;
+const R = [3.2, 12];
+const A = [10.8, 7]; // kept
+const B = [10.8, 17]; // kept
+const C = [10.8, 12]; // pruned
+const A1 = [19.4, 3.6]; // kept, best
+const A2 = [19.4, 9.6]; // pruned
+const B1 = [19.4, 14.4]; // kept
+const B2 = [19.4, 20.4]; // pruned
+const STUB = 0.45;
+/** Rescoring: the candidate sprouts to full length, then withers back to its stub. */
+const rescore = (delay) => ({
+    duration: 2.6,
+    repeatAfter: 3.4,
+    frames: [
+        { at: 0 },
+        { at: 0.06 + delay },
+        { at: 0.36 + delay, draw: 1 - STUB, opacity: 0.4 },
+        { at: 0.5 + delay, draw: 1 - STUB, opacity: 0.4 },
+        { at: 0.86 + delay * 0.5 },
+        { at: 1 },
+    ],
+});
+export const beamSearchArt = {
+    name: 'beam-search',
+    parts: [
+        {
+            name: 'pruned-step-1',
+            paths: [branch(R, C)],
+            traceLength: 14,
+            poses: [{ opacity: 0.28 }, { draw: STUB, opacity: 0.5 }, { draw: 0, opacity: 0 }],
+            gestures: [null, rescore(0), null],
+        },
+        {
+            name: 'pruned-step-2',
+            paths: [branch(A, A2), branch(B, B2)],
+            traceLength: 14,
+            poses: [{ opacity: 0.28 }, { draw: STUB, opacity: 0.5 }, { draw: 0, opacity: 0 }],
+            gestures: [null, rescore(0.12), null],
+        },
+        {
+            name: 'beams-step-1',
+            paths: [branch(R, A), branch(R, B)],
+            poses: [{}, {}, { opacity: 0.4 }],
+        },
+        {
+            name: 'beams-step-2',
+            paths: [branch(A, A1), branch(B, B1)],
+            poses: [{}, {}, { opacity: 0.4 }],
+        },
+        {
+            name: 'root',
+            paths: [`M${R[0] - 2} ${R[1]}a2 2 0 1 0 4 0a2 2 0 1 0 -4 0Z`],
+            fillOnly: 'ink',
+            poses: [{}, {}, {}],
+        },
+        {
+            // The highest-scoring sequence, traced from the prompt to its final token.
+            name: 'best-beam',
+            paths: [
+                `M${R[0]} ${R[1]}L${A[0] - NODE} ${A[1]}a${NODE} ${NODE} 0 1 0 ${2 * NODE} 0a${NODE} ${NODE} 0 1 0 ${-2 * NODE} 0` +
+                    `L${A1[0] - NODE} ${A1[1]}a${NODE} ${NODE} 0 1 0 ${2 * NODE} 0a${NODE} ${NODE} 0 1 0 ${-2 * NODE} 0`,
+            ],
+            accent: true,
+            traceLength: 28.5,
+            poses: [{ draw: 0, opacity: 0 }, { draw: 0, opacity: 0 }, {}],
+            gestures: [
+                null,
+                null,
+                {
+                    duration: 1.3,
+                    repeatAfter: 1.3,
+                    loop: false,
+                    frames: [{ at: 0, draw: -1 }, { at: 0.15, draw: -1 }, { at: 0.85 }, { at: 1 }],
+                },
+            ],
+        },
+    ],
+};

package/dist/icons/causal-mask/causal-mask-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type CausalMaskState } from "./causal-mask-rig.js";
+export { causalMaskStates, type CausalMaskState } from "./causal-mask-rig.js";
+export type CausalMaskIconProps = StatefulIconProps<CausalMaskState>;
+export declare const CausalMaskIcon: import("react").NamedExoticComponent<CausalMaskIconProps>;

package/dist/icons/causal-mask/causal-mask-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { causalMaskArt, causalMaskStates } from "./causal-mask-rig.js";
+export { causalMaskStates } from "./causal-mask-rig.js";
+export const CausalMaskIcon = memo(function CausalMaskIcon(props) {
+    return _jsx(ArticulatedIcon, { art: causalMaskArt, states: causalMaskStates, ...props });
+});

package/dist/icons/causal-mask/causal-mask-rig.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The attention matrix as a framed 4×4 grid of cells. Each query row holds cells only up to its
+ * own column, so the cells form a lower-triangular staircase and the future (upper right) stays
+ * blank. Lifting the mask grows the missing cells in place.
+ */
+export declare const causalMaskStates: readonly ["masked", "decoding", "bidirectional"];
+export type CausalMaskState = (typeof causalMaskStates)[number];
+export declare const causalMaskArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        poses: {}[];
+        pathOffsets?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        gestures?: undefined;
+    } | {
+        poses: ({
+            opacity?: undefined;
+        } | {
+            opacity: number;
+        })[];
+        name: string;
+        paths: string[];
+        pathStates: string[][];
+        fillOnly: "ink";
+        pathOffsets?: undefined;
+        accent?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        pathOffsets: number[][];
+        fillOnly: "ink";
+        accent: true;
+        poses: ({
+            opacity: number;
+        } | {
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            frames: ({
+                at: number;
+                opacity?: undefined;
+                flex?: undefined;
+            } | {
+                at: number;
+                opacity: number;
+                flex?: undefined;
+            } | {
+                at: number;
+                opacity: number;
+                flex: number;
+            } | {
+                at: number;
+                flex: number;
+                opacity?: undefined;
+            })[];
+        } | null)[];
+    })[];
+};

package/dist/icons/causal-mask/causal-mask-rig.js

@@ -0,0 +1,75 @@
+/**
+ * The attention matrix as a framed 4×4 grid of cells. Each query row holds cells only up to its
+ * own column, so the cells form a lower-triangular staircase and the future (upper right) stays
+ * blank. Lifting the mask grows the missing cells in place.
+ */
+export const causalMaskStates = ['masked', 'decoding', 'bidirectional'];
+const left = 5.5;
+const size = 2.35;
+const gap = 1.2;
+const pitch = size + gap;
+const f = (n) => +n.toFixed(2);
+const square = (x1, x2, row) => {
+    const top = f(left + pitch * (row - 1));
+    return `M${f(x1)} ${top}H${f(x2)}V${f(top + size)}H${f(x1)}Z`;
+};
+/** Cells 1..4 of a row; cells beyond `reach` are collapsed to zero width at their own left edge. */
+const cells = (row, reach) => [1, 2, 3, 4]
+    .map((j) => {
+    const x = left + pitch * (j - 1);
+    return square(x, j <= reach ? x + size : x, row);
+})
+    .join('');
+const row = (index) => ({
+    name: `row-${index}`,
+    paths: [cells(index, index)],
+    pathStates: [[cells(index, index)], [cells(index, index)], [cells(index, 4)]],
+    fillOnly: 'ink',
+    poses: [{}, {}, {}],
+});
+// Query row flex: 1 collapses cells 2–4 to zero width in place; 0 is the full row.
+const queryOffsets = [1, 2, 3, 4].flatMap((j) => (j === 1 ? [0, 0, 0, 0, 0] : [0, 0, -size, 0, 0]));
+export const causalMaskArt = {
+    name: 'causal-mask',
+    parts: [
+        {
+            name: 'matrix-frame',
+            paths: [
+                'M5 3.5H19C19.8 3.5 20.5 4.2 20.5 5V19C20.5 19.8 19.8 20.5 19 20.5H5C4.2 20.5 3.5 19.8 3.5 19V5C3.5 4.2 4.2 3.5 5 3.5Z',
+            ],
+            poses: [{}, {}, {}],
+        },
+        row(1),
+        row(2),
+        row(3),
+        {
+            ...row(4),
+            poses: [{}, { opacity: 0 }, {}],
+        },
+        {
+            // The query row being generated: accent while decoding; its key cells fill in from zero width.
+            name: 'query-row',
+            paths: [cells(4, 4)],
+            pathOffsets: [queryOffsets],
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{ opacity: 0 }, {}, { opacity: 0 }],
+            gestures: [
+                null,
+                {
+                    duration: 2.8,
+                    repeatAfter: 3.6,
+                    frames: [
+                        { at: 0 },
+                        { at: 0.16, opacity: -1 },
+                        { at: 0.22, opacity: -1, flex: 1 },
+                        { at: 0.36, flex: 1 },
+                        { at: 0.82 },
+                        { at: 1 },
+                    ],
+                },
+                null,
+            ],
+        },
+    ],
+};

package/dist/icons/chunking/chunking-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type ChunkingState } from "./chunking-rig.js";
+export { chunkingStates, type ChunkingState } from "./chunking-rig.js";
+export type ChunkingIconProps = StatefulIconProps<ChunkingState>;
+export declare const ChunkingIcon: import("react").NamedExoticComponent<ChunkingIconProps>;

package/dist/icons/chunking/chunking-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { chunkingArt, chunkingStates } from "./chunking-rig.js";
+export { chunkingStates } from "./chunking-rig.js";
+export const ChunkingIcon = memo(function ChunkingIcon(props) {
+    return _jsx(ArticulatedIcon, { art: chunkingArt, states: chunkingStates, ...props });
+});

package/dist/icons/chunking/chunking-rig.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A page is cut twice, so the top and bottom pieces both keep the middle line between the
+ * cuts: two chunks that overlap by one shared line.
+ */
+export declare const chunkingStates: readonly ["document", "splitting", "chunked"];
+export type ChunkingState = (typeof chunkingStates)[number];
+export declare const chunkingArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        poses: {}[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                x: number;
+                y: number;
+                opacity: number;
+            } | {
+                at: number;
+                x?: undefined;
+                y?: undefined;
+                opacity?: undefined;
+            })[];
+        } | null)[];
+    } | {
+        name: string;
+        paths: string[];
+        pathStates: string[][];
+        detail: boolean;
+        accent: boolean;
+        traceLength: number;
+        poses: ({
+            opacity: number;
+            draw: number;
+        } | {
+            opacity?: undefined;
+            draw?: undefined;
+        } | {
+            opacity: number;
+            x: number;
+            y: number;
+            draw?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                x: number;
+                y: number;
+                opacity: number;
+            } | {
+                at: number;
+                x?: undefined;
+                y?: undefined;
+                opacity?: undefined;
+            })[];
+        } | {
+            duration: number;
+            repeatAfter: number;
+            interpolation: "continuous";
+            frames: ({
+                at: number;
+                x?: undefined;
+            } | {
+                at: number;
+                x: number;
+            })[];
+        } | null)[];
+    })[];
+};

package/dist/icons/chunking/chunking-rig.js

@@ -0,0 +1,91 @@
+/**
+ * A page is cut twice, so the top and bottom pieces both keep the middle line between the
+ * cuts: two chunks that overlap by one shared line.
+ */
+export const chunkingStates = ['document', 'splitting', 'chunked'];
+const L = 7.9;
+const R = 16.1;
+const CUT_TOP = 9.5; // top edge of the lower chunk
+const CUT_BOTTOM = 14.5; // bottom edge of the upper chunk
+// Side by side with a 2.8-unit gutter between the facing edges.
+const UP = { x: -5.5, y: -1.6 };
+const DOWN = { x: 5.5, y: 1.6 };
+/**
+ * Pieces wait until the cuts exist, then slide apart along the diagonal. `fade` crossfades a
+ * coincident accent cut into the piece's ink edge while it travels (+1 fades out, -1 in).
+ */
+const separate = (to, fade = 0) => ({
+    duration: 1.4,
+    repeatAfter: 1.4,
+    loop: false,
+    frames: [
+        { at: 0, x: -to.x, y: -to.y, opacity: fade },
+        { at: 0.3, x: -to.x, y: -to.y, opacity: fade },
+        { at: 0.85 },
+        { at: 1 },
+    ],
+});
+const piece = (name, path, to, extra = {}) => ({
+    name,
+    paths: [path],
+    poses: [{}, {}, { ...to }],
+    gestures: [null, null, separate(to)],
+    ...extra,
+});
+const cut = (name, y, to, sign) => {
+    const short = `M${L} ${y}H${R}`;
+    const long = `M${L - 2} ${y}H${R + 2}`;
+    return {
+        name,
+        paths: [short],
+        pathStates: [[short], [long], [short]],
+        // Thinner than the outline so cut, shared line and cut stay separate at 24 px.
+        detail: true,
+        accent: true,
+        traceLength: 13,
+        // In the chunked state the accent cut hands over to the piece's ink edge.
+        poses: [{ opacity: 0, draw: 0 }, {}, { ...to, opacity: 0 }],
+        gestures: [
+            null,
+            {
+                // Pending cut: the two blades saw in opposite directions.
+                duration: 2,
+                repeatAfter: 2.8,
+                interpolation: 'continuous',
+                frames: [{ at: 0 }, { at: 0.3, x: 0.9 * sign }, { at: 0.7, x: -0.9 * sign }, { at: 1 }],
+            },
+            separate(to, 1),
+        ],
+    };
+};
+/** The cut becomes an ordinary closed edge of its chunk. */
+const edge = (name, y, to) => ({
+    name,
+    paths: [`M${L} ${y}H${R}`],
+    poses: [{ opacity: 0 }, { opacity: 0 }, { ...to }],
+    gestures: [null, null, separate(to, -1)],
+});
+export const chunkingArt = {
+    name: 'chunking',
+    parts: [
+        piece('upper-piece', `M${L} ${CUT_BOTTOM}V5.3C${L} 4.75 8.35 4.3 8.9 4.3H15.1C15.65 4.3 ${R} 4.75 ${R} 5.3V${CUT_BOTTOM}`, UP),
+        piece('lower-piece', `M${L} ${CUT_TOP}V18.7C${L} 19.25 8.35 19.7 8.9 19.7H15.1C15.65 19.7 ${R} 19.25 ${R} 18.7V${CUT_TOP}`, DOWN),
+        piece('upper-lines', 'M9.9 7H14.1M9.9 12H14.1', UP, { detail: true }),
+        piece('lower-line', 'M9.9 17H13', DOWN, { detail: true }),
+        edge('upper-edge', CUT_BOTTOM, UP),
+        edge('lower-edge', CUT_TOP, DOWN),
+        // The shared line is copied into both pieces: the overlap.
+        piece('shared-upper', 'M9.9 12H14.1', UP, {
+            detail: true,
+            accent: true,
+            poses: [{ opacity: 0 }, {}, { ...UP }],
+        }),
+        piece('shared-lower', 'M9.9 12H14.1', DOWN, {
+            detail: true,
+            accent: true,
+            poses: [{ opacity: 0 }, {}, { ...DOWN }],
+        }),
+        cut('upper-cut', CUT_BOTTOM, UP, 1),
+        cut('lower-cut', CUT_TOP, DOWN, -1),
+    ],
+};

package/dist/icons/code-sandbox/code-sandbox-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type CodeSandboxState } from "./code-sandbox-rig.js";
+export { codeSandboxStates, type CodeSandboxState } from "./code-sandbox-rig.js";
+export type CodeSandboxIconProps = StatefulIconProps<CodeSandboxState>;
+export declare const CodeSandboxIcon: import("react").NamedExoticComponent<CodeSandboxIconProps>;

package/dist/icons/code-sandbox/code-sandbox-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { codeSandboxArt, codeSandboxStates } from "./code-sandbox-rig.js";
+export { codeSandboxStates } from "./code-sandbox-rig.js";
+export const CodeSandboxIcon = memo(function CodeSandboxIcon(props) {
+    return _jsx(ArticulatedIcon, { art: codeSandboxArt, states: codeSandboxStates, ...props });
+});

package/dist/icons/code-sandbox/code-sandbox-rig.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Agent-written code runs inside a double isolation wall: the running process ricochets off
+ * the inner wall and never leaves; on exit it lands as an output line inside the boundary.
+ */
+export declare const codeSandboxStates: readonly ["idle", "running", "exited"];
+export type CodeSandboxState = (typeof codeSandboxStates)[number];
+export declare const codeSandboxArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        poses: {}[];
+        detail?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+        traceLength?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        detail: true;
+        poses: ({
+            opacity?: undefined;
+        } | {
+            opacity: number;
+        })[];
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+        traceLength?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: [number, number];
+        poses: ({
+            opacity: number;
+            x?: undefined;
+            y?: undefined;
+        } | {
+            opacity?: undefined;
+            x?: undefined;
+            y?: undefined;
+        } | {
+            x: number;
+            y: number;
+            opacity: number;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            interpolation: "continuous";
+            frames: ({
+                at: number;
+                x?: undefined;
+                y?: undefined;
+            } | {
+                at: number;
+                x: number;
+                y: number;
+            })[];
+        } | null)[];
+        detail?: undefined;
+        traceLength?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        detail: true;
+        accent: true;
+        traceLength: number;
+        poses: ({
+            opacity: number;
+        } | {
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                draw: number;
+            } | {
+                at: number;
+                draw?: undefined;
+            })[];
+        } | null)[];
+        fillOnly?: undefined;
+        pivot?: undefined;
+    })[];
+};

package/dist/icons/code-sandbox/code-sandbox-rig.js

@@ -0,0 +1,74 @@
+/**
+ * Agent-written code runs inside a double isolation wall: the running process ricochets off
+ * the inner wall and never leaves; on exit it lands as an output line inside the boundary.
+ */
+export const codeSandboxStates = ['idle', 'running', 'exited'];
+const rounded = (x1, y1, x2, y2, r) => `M${x1 + r} ${y1}H${x2 - r}A${r} ${r} 0 0 1 ${x2} ${y1 + r}V${y2 - r}A${r} ${r} 0 0 1 ${x2 - r} ${y2}H${x1 + r}A${r} ${r} 0 0 1 ${x1} ${y2 - r}V${y1 + r}A${r} ${r} 0 0 1 ${x1 + r} ${y1}Z`;
+export const codeSandboxArt = {
+    name: 'code-sandbox',
+    parts: [
+        {
+            name: 'outer-wall',
+            paths: [rounded(2.6, 2.6, 21.4, 21.4, 3)],
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'inner-wall',
+            paths: [rounded(5.5, 5.5, 18.5, 18.5, 1.6)],
+            detail: true,
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'code',
+            paths: ['M10.4 8.2L8.2 10.6L10.4 13', 'M13.6 8.2L15.8 10.6L13.6 13'],
+            detail: true,
+            poses: [{}, { opacity: 0.3 }, {}],
+        },
+        {
+            name: 'process',
+            paths: ['M10.8 10.6a1.2 1.2 0 1 0 2.4 0a1.2 1.2 0 1 0 -2.4 0Z'],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: [12, 10.6],
+            // On exit the process travels down to where its output line begins.
+            poses: [{ opacity: 0 }, {}, { x: -4.1, y: 5, opacity: 0 }],
+            gestures: [
+                null,
+                {
+                    // Each landmark is an inner-wall contact: right, bottom, left, top, then back to centre.
+                    duration: 2.8,
+                    repeatAfter: 3.6,
+                    interpolation: 'continuous',
+                    frames: [
+                        { at: 0 },
+                        { at: 0.2, x: 4.3, y: 1.8 },
+                        { at: 0.42, x: 1.2, y: 5.6 },
+                        { at: 0.64, x: -4.3, y: 2.4 },
+                        { at: 0.84, x: -1.4, y: -2.8 },
+                        { at: 1 },
+                    ],
+                },
+                null,
+            ],
+        },
+        {
+            // Left-aligned like a line of program output (a centred line would read as a mouth).
+            name: 'output',
+            paths: ['M7.9 15.6H12.6'],
+            detail: true,
+            accent: true,
+            traceLength: 5,
+            poses: [{ opacity: 0 }, { opacity: 0 }, {}],
+            gestures: [
+                null,
+                null,
+                {
+                    duration: 0.8,
+                    repeatAfter: 0.8,
+                    loop: false,
+                    frames: [{ at: 0, draw: -1 }, { at: 0.2, draw: -1 }, { at: 0.9 }, { at: 1 }],
+                },
+            ],
+        },
+    ],
+};

package/dist/icons/entity-extraction/entity-extraction-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type EntityExtractionState } from "./entity-extraction-rig.js";
+export { entityExtractionStates, type EntityExtractionState } from "./entity-extraction-rig.js";
+export type EntityExtractionIconProps = StatefulIconProps<EntityExtractionState>;
+export declare const EntityExtractionIcon: import("react").NamedExoticComponent<EntityExtractionIconProps>;

package/dist/icons/entity-extraction/entity-extraction-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { entityExtractionArt, entityExtractionStates, } from "./entity-extraction-rig.js";
+export { entityExtractionStates } from "./entity-extraction-rig.js";
+export const EntityExtractionIcon = memo(function EntityExtractionIcon(props) {
+    return _jsx(ArticulatedIcon, { art: entityExtractionArt, states: entityExtractionStates, ...props });
+});