agentlas 1.0.42 → 1.0.44

package/engine/vendor/mermaid/canvas.js

@@ -0,0 +1,366 @@
+import { measured } from './width.js';
+/**
+ * Sentinel occupying the trailing column of a wide glyph. Never emitted: the
+ * line builder skips it so a CJK character claims two cells of layout but
+ * contributes one character of output.
+ */
+export const CONT = String.fromCharCode(0);
+/** Connection direction bits, combined into a box-drawing glyph by `maskChar`. */
+export const U = 1;
+export const D = 2;
+export const L = 4;
+export const R = 8;
+/** Line styles, tracked per cell so crossing edges keep their own stroke. */
+export const STY_DOT = 1;
+export const STY_THICK = 2;
+export const STY_SOLID = 4;
+/**
+ * A grid of cells. Edges accumulate as direction bits rather than glyphs so
+ * that crossings and junctions resolve correctly whatever order they are drawn
+ * in; `finalizeMask` turns the accumulated bits into characters at the end.
+ *
+ * `occupied` marks cells claimed by a box, which edge bits must not overwrite.
+ */
+export class Canvas {
+    w;
+    h;
+    ch;
+    cls;
+    mask;
+    style;
+    occupied;
+    curStyle = STY_SOLID;
+    constructor(w, h) {
+        const n = w * h;
+        this.w = w;
+        this.h = h;
+        this.ch = new Array(n).fill(' ');
+        this.cls = new Array(n).fill('none');
+        this.mask = new Uint8Array(n);
+        this.style = new Uint8Array(n);
+        this.occupied = new Uint8Array(n);
+    }
+    idx(x, y) {
+        return y * this.w + x;
+    }
+    set(x, y, c, cls) {
+        if (x >= this.w || y >= this.h)
+            return;
+        const i = this.idx(x, y);
+        this.ch[i] = c;
+        this.cls[i] = cls;
+    }
+    /**
+     * Accumulate direction bits on a free cell.
+     *
+     * `cls` is the class to claim the cell for; `border` cells are never
+     * reclassified, so a connector meeting a box keeps the box's styling.
+     */
+    addBits(x, y, bits, cls = 'edge') {
+        if (x >= this.w || y >= this.h)
+            return;
+        const i = this.idx(x, y);
+        if (this.occupied[i])
+            return;
+        this.mask[i] |= bits;
+        this.style[i] |= this.curStyle;
+        if (this.cls[i] !== 'border')
+            this.cls[i] = cls;
+    }
+    /** Stamp a finished sub-canvas (a subgraph frame's contents) at an offset. */
+    blit(sub, ox, oy) {
+        for (let sy = 0; sy < sub.h; sy++) {
+            for (let sx = 0; sx < sub.w; sx++) {
+                const x = ox + sx;
+                const y = oy + sy;
+                if (x >= this.w || y >= this.h)
+                    continue;
+                const si = sub.idx(sx, sy);
+                const di = this.idx(x, y);
+                this.ch[di] = sub.ch[si];
+                this.cls[di] = sub.cls[si];
+                this.style[di] = sub.style[si];
+                this.occupied[di] = 1;
+            }
+        }
+    }
+    /** Add direction bits even to an occupied cell, so an edge can meet a border. */
+    junction(x, y, bits) {
+        if (x >= this.w || y >= this.h)
+            return;
+        const i = this.idx(x, y);
+        this.mask[i] |= bits;
+        if (this.cls[i] !== 'border')
+            this.cls[i] = 'edge';
+    }
+    segV(x, y0, y1) {
+        const a = Math.min(y0, y1);
+        const b = Math.max(y0, y1);
+        for (let y = a; y <= b; y++) {
+            let bits = 0;
+            if (y > a)
+                bits |= U;
+            if (y < b)
+                bits |= D;
+            this.addBits(x, y, bits);
+        }
+    }
+    segH(y, x0, x1) {
+        const a = Math.min(x0, x1);
+        const b = Math.max(x0, x1);
+        for (let x = a; x <= b; x++) {
+            let bits = 0;
+            if (x > a)
+                bits |= L;
+            if (x < b)
+                bits |= R;
+            this.addBits(x, y, bits);
+        }
+    }
+    /** Resolve accumulated direction bits into glyphs, honouring line style. */
+    finalizeMask() {
+        for (let i = 0; i < this.ch.length; i++) {
+            if (this.mask[i] !== 0 && this.ch[i] === ' ') {
+                const c = maskChar(this.mask[i]);
+                this.ch[i] =
+                    this.style[i] === STY_DOT ? dottedChar(c) : this.style[i] === STY_THICK ? thickChar(c) : c;
+            }
+        }
+    }
+    /**
+     * Mirror top-to-bottom for `BT`. Rows reorder but within-row text does not,
+     * so labels stay readable; box-drawing glyphs flip to match.
+     */
+    flipVertical() {
+        for (let y = 0; y < Math.floor(this.h / 2); y++) {
+            const y2 = this.h - 1 - y;
+            for (let x = 0; x < this.w; x++) {
+                const i = this.idx(x, y);
+                const j = this.idx(x, y2);
+                [this.ch[i], this.ch[j]] = [this.ch[j], this.ch[i]];
+                [this.cls[i], this.cls[j]] = [this.cls[j], this.cls[i]];
+            }
+        }
+        for (let i = 0; i < this.ch.length; i++)
+            this.ch[i] = flipGlyphV(this.ch[i]);
+    }
+    /**
+     * Mirror left-to-right for `RL`. Mirroring reverses each row, so after
+     * flipping glyphs each text/label run is reversed back to reading order.
+     */
+    flipHorizontal() {
+        for (let y = 0; y < this.h; y++) {
+            for (let x = 0; x < Math.floor(this.w / 2); x++) {
+                const x2 = this.w - 1 - x;
+                const i = this.idx(x, y);
+                const j = this.idx(x2, y);
+                [this.ch[i], this.ch[j]] = [this.ch[j], this.ch[i]];
+                [this.cls[i], this.cls[j]] = [this.cls[j], this.cls[i]];
+            }
+        }
+        for (let i = 0; i < this.ch.length; i++)
+            this.ch[i] = flipGlyphH(this.ch[i]);
+        for (let y = 0; y < this.h; y++) {
+            let x = 0;
+            while (x < this.w) {
+                const cls = this.cls[this.idx(x, y)];
+                if (cls === 'text' || cls === 'edgeLabel') {
+                    const start = this.idx(x, y);
+                    while (x < this.w && this.cls[this.idx(x, y)] === cls)
+                        x++;
+                    const end = this.idx(x, y);
+                    reverseSlice(this.ch, start, end);
+                }
+                else {
+                    x++;
+                }
+            }
+        }
+    }
+    /** Group each row into runs of one class, dropping wide-glyph continuations. */
+    toLines() {
+        const plain = [];
+        const styled = [];
+        let width = 0;
+        for (let y = 0; y < this.h; y++) {
+            // A trailing CONT counts as painted: it is the second cell of a wide
+            // glyph, so the row really does reach that column.
+            let last = 0;
+            for (let x = this.w - 1; x >= 0; x--) {
+                if (this.ch[this.idx(x, y)] !== ' ') {
+                    last = x + 1;
+                    break;
+                }
+            }
+            width = Math.max(width, last);
+            const spans = [];
+            let plainRow = '';
+            let run = '';
+            let runCls = 'none';
+            for (let x = 0; x < last; x++) {
+                const i = this.idx(x, y);
+                const c = this.ch[i];
+                if (c === CONT)
+                    continue;
+                const cls = this.cls[i];
+                plainRow += c;
+                if (cls !== runCls && run !== '') {
+                    spans.push({ text: run, cls: runCls });
+                    run = '';
+                }
+                runCls = cls;
+                run += c;
+            }
+            if (run !== '')
+                spans.push({ text: run, cls: runCls });
+            styled.push(spans);
+            // Only ASCII spaces, which is all a blank cell ever holds. Trimming `\s`
+            // would eat a trailing NBSP that `styled` keeps, desyncing the two.
+            plain.push(plainRow.replace(/ +$/, ''));
+        }
+        let first = 0;
+        while (first < plain.length && plain[first] === '')
+            first++;
+        let end = plain.length;
+        while (end > first && plain[end - 1] === '')
+            end--;
+        return { plain: plain.slice(first, end), styled: styled.slice(first, end), width };
+    }
+}
+function reverseSlice(arr, start, end) {
+    for (let i = start, j = end - 1; i < j; i++, j--) {
+        ;
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+}
+/**
+ * Paint `text` at `x, y`, one grapheme cluster per cell.
+ *
+ * A wide cluster claims a second cell, marked with `CONT` so the line builder
+ * emits one character for it rather than a stray space.
+ */
+export function drawText(canvas, text, x, y, cls) {
+    let cur = x;
+    for (const [cluster, cw] of measured(text)) {
+        if (cw === 0)
+            continue;
+        canvas.set(cur, y, cluster, cls);
+        for (let k = 1; k < cw; k++)
+            canvas.set(cur + k, y, CONT, cls);
+        cur += cw;
+    }
+}
+/**
+ * Paint `text` at `x, y`, clearing any edge bits underneath first.
+ *
+ * Used where text sits on top of a drawn line (sequence messages, dividers,
+ * compartment rows) and must win over it.
+ */
+export function drawTextOverEdges(canvas, text, x, y, cls) {
+    let cur = x;
+    for (const [cluster, cw] of measured(text)) {
+        if (cw === 0)
+            continue;
+        for (let k = 0; k < cw; k++) {
+            if (cur + k < canvas.w && y < canvas.h)
+                canvas.mask[canvas.idx(cur + k, y)] = 0;
+            canvas.set(cur + k, y, k === 0 ? cluster : CONT, cls);
+        }
+        cur += cw;
+    }
+}
+export function maskChar(mask) {
+    switch (mask) {
+        case 0:
+            return ' ';
+        case U:
+        case D:
+        case U | D:
+            return '│';
+        case L:
+        case R:
+        case L | R:
+            return '─';
+        case D | R:
+            return '┌';
+        case D | L:
+            return '┐';
+        case U | R:
+            return '└';
+        case U | L:
+            return '┘';
+        case U | D | R:
+            return '├';
+        case U | D | L:
+            return '┤';
+        case D | L | R:
+            return '┬';
+        case U | L | R:
+            return '┴';
+        default:
+            return '┼';
+    }
+}
+const DOTTED = { '─': '╌', '│': '╎' };
+const THICK = {
+    '─': '━',
+    '│': '┃',
+    '┌': '┏',
+    '┐': '┓',
+    '└': '┗',
+    '┘': '┛',
+    '├': '┣',
+    '┤': '┫',
+    '┬': '┳',
+    '┴': '┻',
+    '┼': '╋',
+};
+const FLIP_V = {
+    '┌': '└',
+    '└': '┌',
+    '┐': '┘',
+    '┘': '┐',
+    '┏': '┗',
+    '┗': '┏',
+    '┓': '┛',
+    '┛': '┓',
+    '╭': '╰',
+    '╰': '╭',
+    '╮': '╯',
+    '╯': '╮',
+    '┬': '┴',
+    '┴': '┬',
+    '┳': '┻',
+    '┻': '┳',
+    '▼': '▲',
+    '▲': '▼',
+    '▽': '△',
+    '△': '▽',
+};
+const FLIP_H = {
+    '┌': '┐',
+    '┐': '┌',
+    '└': '┘',
+    '┘': '└',
+    '┏': '┓',
+    '┓': '┏',
+    '┗': '┛',
+    '┛': '┗',
+    '╭': '╮',
+    '╮': '╭',
+    '╰': '╯',
+    '╯': '╰',
+    '├': '┤',
+    '┤': '├',
+    '┣': '┫',
+    '┫': '┣',
+    '▶': '◄',
+    '◄': '▶',
+    '▷': '◁',
+    '◁': '▷',
+};
+export const dottedChar = (c) => DOTTED[c] ?? c;
+export const thickChar = (c) => THICK[c] ?? c;
+export const flipGlyphV = (c) => FLIP_V[c] ?? c;
+export const flipGlyphH = (c) => FLIP_H[c] ?? c;
+//# sourceMappingURL=canvas.js.map

package/engine/vendor/mermaid/graph.js

@@ -0,0 +1,91 @@
+/**
+ * The shared diagram model. Flowchart, state, class and ER sources all parse
+ * into a `Graph`; only sequence diagrams have their own model.
+ */
+import { asciiUpper } from './labels.js';
+/** Caps that keep layout bounded; exceeding one drops the diagram to fallback. */
+export const MAX_NODES = 128;
+export const MAX_EDGES = 512;
+export const MAX_GROUPS = 24;
+export const MAX_GROUP_DEPTH = 6;
+/** Class members / ER attributes listed per box before eliding with `…`. */
+export const MAX_MEMBERS = 8;
+export const emptyClassInfo = () => ({ annotation: null, attrs: [], methods: [] });
+/** `LR`/`RL`/`BT` as written in a header or `direction` statement; else `down`. */
+export function parseDir(token) {
+    switch (asciiUpper(token)) {
+        case 'LR':
+            return 'right';
+        case 'RL':
+            return 'left';
+        case 'BT':
+            return 'up';
+        default:
+            return 'down';
+    }
+}
+export class Graph {
+    nodes = [];
+    edges = [];
+    index = new Map();
+    groups = [];
+    /** Innermost subgraph each node was declared in, parallel to `nodes`. */
+    nodeGroup = [];
+    curGroup = null;
+    /** Set when a cap was hit; the caller abandons the parse. */
+    overCap = false;
+    /**
+     * Text the flowchart grammar could not read and silently discarded.
+     *
+     * Flowchart parsing is deliberately lenient — a malformed statement
+     * contributes whatever prefix parsed and the rest is dropped — so without
+     * these the reader gets a clean diagram that is not what they wrote.
+     */
+    warnings = [];
+    dir = 'down';
+    constructor(dir = 'down') {
+        this.dir = dir;
+    }
+    /**
+     * Index of `id`, creating the node if new. A later declaration carrying a
+     * label overwrites the placeholder one an edge created. Returns `null` once
+     * `MAX_NODES` is reached, which aborts the parse.
+     */
+    nodeIndex(id, label, shape) {
+        const existing = this.index.get(id);
+        if (existing !== undefined) {
+            if (label !== null) {
+                this.nodes[existing].label = label;
+                this.nodes[existing].shape = shape;
+            }
+            return existing;
+        }
+        if (this.nodes.length >= MAX_NODES) {
+            this.overCap = true;
+            return null;
+        }
+        this.index.set(id, this.nodes.length);
+        this.nodes.push({ label: label ?? id, shape });
+        this.nodeGroup.push(this.curGroup);
+        return this.nodes.length - 1;
+    }
+    /** Set a node's label without disturbing its shape, creating it if new. */
+    nodeLabel(id, label) {
+        const existing = this.index.get(id);
+        if (existing !== undefined) {
+            this.nodes[existing].label = label;
+            return existing;
+        }
+        return this.nodeIndex(id, label, 'round');
+    }
+    /** Append an edge, or flag `overCap` when `MAX_EDGES` is reached. */
+    pushEdge(edge) {
+        if (this.edges.length >= MAX_EDGES) {
+            this.overCap = true;
+            return false;
+        }
+        this.edges.push(edge);
+        return true;
+    }
+}
+//# sourceMappingURL=graph.js.map

package/engine/vendor/mermaid/index.js

@@ -0,0 +1,100 @@
+import { stripControls } from './labels.js';
+import { layoutClass, layoutFlowchart, layoutGrouped } from './layout.js';
+import { layoutSequence } from './layout-seq.js';
+import { diagramKind, parseClass, parseEr, parseGraph, parseSequence, parseState } from './parse.js';
+export { DEFAULT_THEME, toAnsi } from './ansi.js';
+export { diagramKind } from './parse.js';
+export { sourceBox } from './source-box.js';
+/**
+ * Render a Mermaid source block as Unicode box-drawing art.
+ *
+ * Supported: `graph`/`flowchart` (including `subgraph`), `stateDiagram`,
+ * `classDiagram`, `erDiagram` and `sequenceDiagram`.
+ *
+ * The diagram is laid out at whatever size it needs; `art.width` reports the
+ * columns that turned out to be. Deciding what to do when that exceeds the
+ * space at hand is the caller's — `sourceBox` is the usual answer:
+ *
+ * ```ts
+ * const art = render(src)
+ * show(art && art.width <= cols ? art : sourceBox(src, cols))
+ * ```
+ *
+ * `null` means there is no art to show: blank input, a syntax error, a diagram
+ * type this renderer does not draw, or one large enough that laying it out is
+ * refused. `diagramKind` separates the middle two.
+ *
+ * Rendering is best-effort. A flowchart keeps whatever parsed; the stricter
+ * grammars additionally get one retry without their final line, which is what
+ * keeps a streaming diagram on screen while its last statement is half-typed.
+ * Everything given up on is listed in `art.warnings` — advisory only, never a
+ * reason to withhold the art.
+ */
+export function render(src) {
+    src = stripControls(src);
+    if (src.trim() === '')
+        return null;
+    const drawn = attempt(src);
+    if (drawn === null)
+        return null;
+    return { ...drawn.canvas.toLines(), warnings: drawn.warnings };
+}
+/**
+ * Draw `src`, retrying once without its last line if the grammar rejects it.
+ *
+ * State, class, ER and sequence fail a whole diagram on one unreadable
+ * statement, and while a source is streaming its last line is usually still
+ * being typed — so without this a diagram alternates with the source box all
+ * the way in. Only the final line is dropped, and doing so is always reported,
+ * so a finished document with a bad last line still says what it lost rather
+ * than quietly rendering short.
+ */
+function attempt(src) {
+    const drawn = draw(src);
+    if (drawn !== null)
+        return drawn;
+    const body = src.replace(/\s+$/, '');
+    const cut = body.lastIndexOf('\n');
+    if (cut === -1)
+        return null;
+    const salvaged = draw(body.slice(0, cut));
+    if (salvaged === null)
+        return null;
+    const dropped = body.slice(cut + 1).trim();
+    return {
+        canvas: salvaged.canvas,
+        warnings: [...salvaged.warnings, `dropped, unreadable final line: "${dropped}"`],
+    };
+}
+/** Dispatch on the declared diagram type; `null` means nothing was drawn. */
+function draw(src) {
+    const plain = (canvas) => (canvas === null ? null : { canvas, warnings: [] });
+    switch (diagramKind(src)) {
+        case 'flowchart': {
+            const graph = parseGraph(src);
+            if (graph === null)
+                return null;
+            const canvas = graph.groups.length === 0 ? layoutFlowchart(graph) : layoutGrouped(graph);
+            return canvas === null ? null : { canvas, warnings: graph.warnings };
+        }
+        case 'state': {
+            const state = parseState(src);
+            return state === null ? null : plain(layoutFlowchart(state));
+        }
+        case 'class': {
+            const cls = parseClass(src);
+            return cls === null ? null : plain(layoutClass(cls.graph, cls.infos));
+        }
+        case 'er': {
+            const er = parseEr(src);
+            return er === null ? null : plain(layoutClass(er.graph, er.infos));
+        }
+        case 'sequence': {
+            const seq = parseSequence(src);
+            return seq === null ? null : plain(layoutSequence(seq));
+        }
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=index.js.map