@copilotkit/channels-teams 0.1.0

package/dist/render/adaptive-card.js

@@ -0,0 +1,401 @@
+import { TEAMS_LIMITS, truncateText, clampArray } from "./budget.js";
+/** Teams attachment content type for an Adaptive Card. */
+export const ADAPTIVE_CARD_CONTENT_TYPE = "application/vnd.microsoft.card.adaptive";
+const SCHEMA = "http://adaptivecards.io/schemas/adaptive-card.json";
+const VERSION = "1.5";
+/**
+ * Render a cross-platform component IR tree (already expanded by `renderToIR`
+ * and pre-bound by the action registry, so event props are `{ id }`) into a
+ * Teams **Adaptive Card** (1.5).
+ *
+ * Structural nodes map to body elements (`<Header>`→bold `TextBlock`,
+ * `<Section>`/`<Markdown>`→wrapped `TextBlock`, `<Fields>`→`FactSet`,
+ * `<Table>`→native `Table`, `<Image>`→`Image`). Interactive nodes split by
+ * Adaptive Card shape: `<Button>`→a top-level `Action.Submit` (per the V1
+ * decision to use `Action.Submit`), while `<Input>`/`<Select>` become
+ * `Input.Text`/`Input.ChoiceSet` in the body. Each action/input carries the
+ * registry-stamped opaque id in its `data`/`id` so a later interaction can be
+ * decoded back into the engine (round-trip is a follow-up; rendering is here).
+ *
+ * The renderer is total: unknown intrinsics are skipped. Collections clamp and
+ * text truncates to {@link TEAMS_LIMITS} so the card stays within Teams' payload
+ * ceiling.
+ */
+export function renderAdaptiveCard(ir) {
+    const body = [];
+    const actions = [];
+    for (const node of ir)
+        renderNode(node, body, actions);
+    const card = {
+        type: "AdaptiveCard",
+        $schema: SCHEMA,
+        version: VERSION,
+        body: clampArray(body, TEAMS_LIMITS.bodyElements).items,
+    };
+    const clampedActions = clampArray(actions, TEAMS_LIMITS.actions).items;
+    if (clampedActions.length > 0)
+        card.actions = clampedActions;
+    return card;
+}
+/** Render a single IR node, pushing body elements and/or top-level actions. */
+function renderNode(node, body, actions) {
+    if (typeof node.type !== "string")
+        return; // non-intrinsic, already expanded
+    const props = node.props ?? {};
+    switch (node.type) {
+        case "message":
+            // The message container is not an element; flatten its children.
+            for (const child of childNodes(node))
+                renderNode(child, body, actions);
+            return;
+        case "header":
+            body.push({
+                type: "TextBlock",
+                text: truncateText(collectText(node), TEAMS_LIMITS.textBlock),
+                size: "Large",
+                weight: "Bolder",
+                wrap: true,
+            });
+            return;
+        case "section":
+        case "markdown":
+            body.push(textBlock(collectText(node)));
+            return;
+        case "text":
+            body.push(textBlock(String(props.value ?? "")));
+            return;
+        case "context":
+            body.push({
+                type: "TextBlock",
+                text: truncateText(collectText(node), TEAMS_LIMITS.textBlock),
+                size: "Small",
+                isSubtle: true,
+                wrap: true,
+            });
+            return;
+        case "divider":
+            // Adaptive Cards has no rule element; a separator line is drawn *above*
+            // an element via `separator: true`. An empty, separated TextBlock reads
+            // as a horizontal divider.
+            body.push({
+                type: "TextBlock",
+                text: " ",
+                separator: true,
+                spacing: "Medium",
+            });
+            return;
+        case "image":
+            body.push({
+                type: "Image",
+                url: String(props.url ?? props.image_url ?? ""),
+                altText: String(props.alt ?? props.altText ?? ""),
+                size: "Auto",
+            });
+            return;
+        case "fields":
+            body.push(factSet(childNodes(node).filter((c) => c.type === "field")));
+            return;
+        case "field":
+            body.push(factSet([node]));
+            return;
+        case "table":
+            body.push(renderTable(node));
+            return;
+        case "chart":
+            body.push(renderChart(node));
+            return;
+        case "actions":
+            for (const child of childNodes(node))
+                renderNode(child, body, actions);
+            return;
+        case "button":
+            actions.push(renderButton(node));
+            return;
+        case "select":
+            body.push(renderSelect(node));
+            return;
+        case "input":
+            body.push(renderInput(node));
+            return;
+        default:
+            // Unknown intrinsic: skip (total renderer).
+            return;
+    }
+}
+function textBlock(text) {
+    return {
+        type: "TextBlock",
+        text: truncateText(text, TEAMS_LIMITS.textBlock),
+        wrap: true,
+    };
+}
+/** A `<Fields>`/`<Field>` group → a `FactSet`. Each field's text is split on
+ *  its first colon into title/value (falling back to a value-only fact). */
+function factSet(fieldNodes) {
+    const { items } = clampArray(fieldNodes, TEAMS_LIMITS.factsPerSet);
+    const facts = items.map((f) => {
+        const text = collectText(f);
+        const idx = text.indexOf(":");
+        if (idx > 0 && idx <= 60) {
+            return {
+                title: truncateText(text.slice(0, idx).trim(), TEAMS_LIMITS.factTitle),
+                value: truncateText(text.slice(idx + 1).trim(), TEAMS_LIMITS.factValue),
+            };
+        }
+        return { title: "", value: truncateText(text, TEAMS_LIMITS.factValue) };
+    });
+    return { type: "FactSet", facts };
+}
+function renderButton(node) {
+    const props = node.props ?? {};
+    // Link button → Action.OpenUrl (opens the URL; carries no submit data).
+    if (typeof props.url === "string" && props.url.length > 0) {
+        return {
+            type: "Action.OpenUrl",
+            title: truncateText(collectText(node), TEAMS_LIMITS.buttonText),
+            url: props.url,
+        };
+    }
+    const action = {
+        type: "Action.Submit",
+        title: truncateText(collectText(node), TEAMS_LIMITS.buttonText),
+    };
+    // Forward-ready: carry the opaque action id + value so a later
+    // `decodeInteraction` can route the submit back into the engine.
+    const id = idFromHandler(props.onClick);
+    const data = {};
+    if (id)
+        data.ckActionId = id;
+    if (props.value !== undefined)
+        data.value = props.value;
+    if (Object.keys(data).length > 0)
+        action.data = data;
+    if (props.style === "danger" || props.style === "destructive") {
+        action.style = "destructive";
+    }
+    else if (props.style === "primary") {
+        action.style = "positive";
+    }
+    return action;
+}
+function renderSelect(node) {
+    const props = node.props ?? {};
+    const options = props.options ?? [];
+    const { items } = clampArray(options, TEAMS_LIMITS.choices);
+    const el = {
+        type: "Input.ChoiceSet",
+        id: idFromHandler(props.onSelect) ?? "select",
+        choices: items.map((o) => ({
+            title: truncateText(String(o.label), TEAMS_LIMITS.choiceLabel),
+            value: String(o.value),
+        })),
+    };
+    // Multi-select: Teams submits the chosen values as a comma-joined string.
+    if (props.multi)
+        el.isMultiSelect = true;
+    if (props.placeholder)
+        el.placeholder = String(props.placeholder);
+    return el;
+}
+function renderInput(node) {
+    const props = node.props ?? {};
+    const el = {
+        type: "Input.Text",
+        id: idFromHandler(props.onSubmit) ?? "input",
+    };
+    if (props.placeholder)
+        el.placeholder = String(props.placeholder);
+    if (props.multiline)
+        el.isMultiline = true;
+    return el;
+}
+/** A `<Table>` → a native Adaptive Cards `Table` (1.5). */
+function renderTable(node) {
+    const props = node.props ?? {};
+    const cell = (text, header = false) => ({
+        type: "TableCell",
+        items: [
+            {
+                type: "TextBlock",
+                text: truncateText(text, TEAMS_LIMITS.cellText),
+                wrap: true,
+                ...(header ? { weight: "Bolder" } : {}),
+            },
+        ],
+    });
+    const columnsProp = props.columns;
+    const columns = columnsProp
+        ? clampArray(columnsProp, TEAMS_LIMITS.tableColumns).items
+        : undefined;
+    const rows = [];
+    if (columns && columns.length > 0) {
+        rows.push({
+            type: "TableRow",
+            cells: columns.map((c) => cell(c.header, true)),
+        });
+    }
+    const rowNodes = childNodes(node).filter((c) => c.type === "row");
+    const { items: dataRows } = clampArray(rowNodes, TEAMS_LIMITS.tableRows);
+    for (const rowNode of dataRows) {
+        const cells = childNodes(rowNode).filter((c) => c.type === "cell");
+        rows.push({
+            type: "TableRow",
+            cells: cells.map((c) => cell(collectText(c))),
+        });
+    }
+    const table = {
+        type: "Table",
+        columns: (columns ?? inferColumns(rowNodes)).map((c) => ({
+            width: 1,
+            ...(typeof c === "object" && "align" in c && c.align
+                ? { horizontalCellContentAlignment: capitalize(c.align) }
+                : {}),
+        })),
+        rows,
+        firstRowAsHeader: !!(columns && columns.length > 0),
+        gridStyle: "default",
+    };
+    return table;
+}
+/**
+ * A `<Chart>` → a native Teams chart element (`Chart.VerticalBar` /
+ * `Chart.HorizontalBar` / `Chart.Line` / `Chart.Pie` / `Chart.Donut`). These
+ * are a Teams host extension: they render in Teams clients whose app manifest
+ * opts into chart support; other Adaptive Card hosts ignore the unknown
+ * element. Data points clamp and labels/title truncate to the budget.
+ */
+function renderChart(node) {
+    const props = node.props ?? {};
+    const type = String(props.type ?? "verticalBar");
+    const title = props.title != null && String(props.title).length > 0
+        ? truncateText(String(props.title), TEAMS_LIMITS.chartTitle)
+        : undefined;
+    const rawData = Array.isArray(props.data)
+        ? props.data
+        : [];
+    const { items } = clampArray(rawData, TEAMS_LIMITS.chartDataPoints);
+    const points = items.map((p) => ({
+        label: truncateText(String(p?.label ?? ""), TEAMS_LIMITS.chartLabel),
+        value: Number.isFinite(Number(p?.value)) ? Number(p?.value) : 0,
+    }));
+    // Fields shared by every chart kind. `showTitle` is meaningless without a
+    // title; `maxWidth` keeps the chart from stretching the whole card.
+    const common = { maxWidth: "520px" };
+    if (title !== undefined) {
+        common.title = title;
+        common.showTitle = true;
+    }
+    // Axis titles apply to the cartesian charts (bar/line), not pie/donut.
+    const withAxes = (el) => {
+        if (props.xAxisTitle != null)
+            el.xAxisTitle = String(props.xAxisTitle);
+        if (props.yAxisTitle != null)
+            el.yAxisTitle = String(props.yAxisTitle);
+        return el;
+    };
+    const xy = points.map((p) => ({ x: p.label, y: p.value }));
+    const slices = points.map((p) => ({ legend: p.label, value: p.value }));
+    switch (type) {
+        case "horizontalBar":
+            return withAxes({ ...common, type: "Chart.HorizontalBar", data: xy });
+        case "line":
+            return withAxes({
+                ...common,
+                type: "Chart.Line",
+                data: [{ legend: title ?? "", values: xy }],
+            });
+        case "pie":
+            return { ...common, type: "Chart.Pie", data: slices };
+        case "donut":
+            return { ...common, type: "Chart.Donut", data: slices };
+        default:
+            // verticalBar — also the fallback for any unrecognized type.
+            return withAxes({
+                ...common,
+                type: "Chart.VerticalBar",
+                showBarValues: true,
+                data: xy,
+            });
+    }
+}
+/** When no explicit `columns` are given, size the grid to the widest row. */
+function inferColumns(rowNodes) {
+    let widest = 0;
+    for (const r of rowNodes) {
+        const n = childNodes(r).filter((c) => c.type === "cell").length;
+        if (n > widest)
+            widest = n;
+    }
+    return Array.from({ length: Math.min(widest, TEAMS_LIMITS.tableColumns) }, () => ({}));
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/** Extract `{ id }` stamped onto an event prop by the action registry, if present. */
+function idFromHandler(handler) {
+    if (handler && typeof handler === "object" && "id" in handler) {
+        const id = handler.id;
+        if (typeof id === "string")
+            return id;
+    }
+    return undefined;
+}
+/** The expanded `children` of an IR node as a `BotNode[]` (empty if none). */
+function childNodes(node) {
+    const children = node.props?.children;
+    if (Array.isArray(children))
+        return children;
+    if (children &&
+        typeof children === "object" &&
+        "type" in children) {
+        return [children];
+    }
+    return [];
+}
+/** Concatenate the `value` of all descendant `text` nodes (depth-first). */
+function collectText(node) {
+    if (typeof node.type === "string" && node.type === "text") {
+        return String(node.props?.value ?? "");
+    }
+    let acc = "";
+    for (const child of childNodes(node))
+        acc += collectText(child);
+    return acc;
+}
+/**
+ * Does this IR collapse to plain text (no structural or interactive elements)?
+ * Such replies are sent as a normal Teams text activity rather than wrapped in
+ * an Adaptive Card. A bare `Echo: hi` shouldn't render as a card.
+ */
+export function isPlainText(ir) {
+    const RICH = new Set([
+        "header",
+        "fields",
+        "field",
+        "table",
+        "row",
+        "cell",
+        "chart",
+        "image",
+        "actions",
+        "button",
+        "select",
+        "input",
+        "divider",
+        "context",
+    ]);
+    const visit = (node) => {
+        if (typeof node.type === "string" && RICH.has(node.type))
+            return false;
+        return childNodes(node).every(visit);
+    };
+    return ir.every(visit);
+}
+/** Plain-text projection of an IR tree (depth-first text, blocks joined). */
+export function collectPlainText(ir) {
+    return ir
+        .map((n) => collectText(n))
+        .filter((s) => s.length > 0)
+        .join("\n\n")
+        .trim();
+}

package/dist/render/adaptive-card.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adaptive-card.test.d.ts.map

package/dist/render/adaptive-card.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-card.test.d.ts","sourceRoot":"","sources":["../../src/render/adaptive-card.test.ts"],"names":[],"mappings":""}

package/dist/render/adaptive-card.test.js

@@ -0,0 +1,240 @@
+import { describe, it, expect } from "vitest";
+import { renderAdaptiveCard, isPlainText, collectPlainText, } from "./adaptive-card.js";
+const text = (value) => ({ type: "text", props: { value } });
+const el = (type, children, props = {}) => ({
+    type,
+    props: { ...props, children },
+});
+const chart = (props) => ({
+    type: "chart",
+    props,
+});
+describe("renderAdaptiveCard", () => {
+    it("emits a versioned AdaptiveCard envelope", () => {
+        const card = renderAdaptiveCard([text("hi")]);
+        expect(card.type).toBe("AdaptiveCard");
+        expect(card.version).toBe("1.5");
+        expect(Array.isArray(card.body)).toBe(true);
+    });
+    it("renders a header as a bold large TextBlock", () => {
+        const card = renderAdaptiveCard([el("header", [text("Title")])]);
+        expect(card.body[0]).toMatchObject({
+            type: "TextBlock",
+            text: "Title",
+            weight: "Bolder",
+            size: "Large",
+        });
+    });
+    it("renders section/markdown as wrapped TextBlocks", () => {
+        const card = renderAdaptiveCard([el("section", [text("Body copy")])]);
+        expect(card.body[0]).toMatchObject({
+            type: "TextBlock",
+            text: "Body copy",
+            wrap: true,
+        });
+    });
+    it("renders <Fields> as a FactSet, splitting 'k: v' into title/value", () => {
+        const card = renderAdaptiveCard([
+            el("fields", [
+                el("field", [text("Status: Open")]),
+                el("field", [text("just a value")]),
+            ]),
+        ]);
+        expect(card.body[0]).toMatchObject({
+            type: "FactSet",
+            facts: [
+                { title: "Status", value: "Open" },
+                { title: "", value: "just a value" },
+            ],
+        });
+    });
+    it("renders a <Button> as a top-level Action.Submit carrying the opaque id", () => {
+        const card = renderAdaptiveCard([
+            el("actions", [
+                el("button", [text("Approve")], {
+                    onClick: { id: "ck:approve" },
+                    value: { decision: "yes" },
+                    style: "primary",
+                }),
+            ]),
+        ]);
+        expect(card.body).toHaveLength(0);
+        expect(card.actions).toEqual([
+            {
+                type: "Action.Submit",
+                title: "Approve",
+                data: { ckActionId: "ck:approve", value: { decision: "yes" } },
+                style: "positive",
+            },
+        ]);
+    });
+    it("renders a url <Button> as an Action.OpenUrl", () => {
+        const card = renderAdaptiveCard([
+            el("actions", [
+                el("button", [text("Open")], { url: "https://dash/deploy/42" }),
+            ]),
+        ]);
+        expect(card.actions).toEqual([
+            { type: "Action.OpenUrl", title: "Open", url: "https://dash/deploy/42" },
+        ]);
+    });
+    it("marks a multi <Select> ChoiceSet as isMultiSelect", () => {
+        const card = renderAdaptiveCard([
+            el("select", [], {
+                multi: true,
+                onSelect: { id: "ck:pick" },
+                options: [{ label: "One", value: "1" }],
+            }),
+        ]);
+        expect(card.body[0]).toMatchObject({
+            type: "Input.ChoiceSet",
+            isMultiSelect: true,
+        });
+    });
+    it("renders <Select>/<Input> as body inputs", () => {
+        const card = renderAdaptiveCard([
+            el("select", [], {
+                onSelect: { id: "ck:pick" },
+                placeholder: "Choose",
+                options: [
+                    { label: "One", value: "1" },
+                    { label: "Two", value: "2" },
+                ],
+            }),
+            el("input", [], { onSubmit: { id: "ck:txt" }, multiline: true }),
+        ]);
+        expect(card.body[0]).toMatchObject({
+            type: "Input.ChoiceSet",
+            id: "ck:pick",
+            placeholder: "Choose",
+            choices: [
+                { title: "One", value: "1" },
+                { title: "Two", value: "2" },
+            ],
+        });
+        expect(card.body[1]).toMatchObject({
+            type: "Input.Text",
+            id: "ck:txt",
+            isMultiline: true,
+        });
+    });
+    it("renders a <Table> as a native Table with a header row", () => {
+        const card = renderAdaptiveCard([
+            el("table", [el("row", [el("cell", [text("a1")]), el("cell", [text("b1")])])], {
+                columns: [{ header: "A" }, { header: "B", align: "right" }],
+            }),
+        ]);
+        const table = card.body[0];
+        expect(table.type).toBe("Table");
+        expect(table.firstRowAsHeader).toBe(true);
+        const rows = table.rows;
+        expect(rows).toHaveLength(2); // header + 1 data row
+        expect(rows[0].type).toBe("TableRow");
+    });
+    it("clamps top-level actions to the Teams ceiling", () => {
+        const buttons = Array.from({ length: 10 }, (_, i) => el("button", [text(`b${i}`)], { onClick: { id: `ck:${i}` } }));
+        const card = renderAdaptiveCard([el("actions", buttons)]);
+        expect(card.actions).toHaveLength(6);
+    });
+    it("skips unknown intrinsics without throwing", () => {
+        const card = renderAdaptiveCard([el("mystery", [text("x")])]);
+        expect(card.body).toHaveLength(0);
+    });
+    it("renders a vertical-bar <Chart> with title and axis titles", () => {
+        const card = renderAdaptiveCard([
+            chart({
+                title: "Tickets",
+                xAxisTitle: "Month",
+                yAxisTitle: "Count",
+                data: [
+                    { label: "Jan", value: 3 },
+                    { label: "Feb", value: 7 },
+                ],
+            }),
+        ]);
+        expect(card.body[0]).toMatchObject({
+            type: "Chart.VerticalBar",
+            title: "Tickets",
+            showTitle: true,
+            showBarValues: true,
+            maxWidth: "520px",
+            xAxisTitle: "Month",
+            yAxisTitle: "Count",
+            data: [
+                { x: "Jan", y: 3 },
+                { x: "Feb", y: 7 },
+            ],
+        });
+    });
+    it("defaults an absent chart type to a vertical bar", () => {
+        const card = renderAdaptiveCard([
+            chart({ title: "T", data: [{ label: "a", value: 1 }] }),
+        ]);
+        expect(card.body[0].type).toBe("Chart.VerticalBar");
+    });
+    it("maps pie/donut to legend+value slices (no axes)", () => {
+        const data = [
+            { label: "Open", value: 4 },
+            { label: "Closed", value: 6 },
+        ];
+        const pie = renderAdaptiveCard([chart({ type: "pie", data })]);
+        expect(pie.body[0]).toMatchObject({
+            type: "Chart.Pie",
+            data: [
+                { legend: "Open", value: 4 },
+                { legend: "Closed", value: 6 },
+            ],
+        });
+        expect(pie.body[0].xAxisTitle).toBeUndefined();
+        const donut = renderAdaptiveCard([chart({ type: "donut", data })]);
+        expect(donut.body[0].type).toBe("Chart.Donut");
+    });
+    it("maps line to a single legended series of values", () => {
+        const card = renderAdaptiveCard([
+            chart({
+                type: "line",
+                title: "Revenue",
+                data: [{ label: "Q1", value: 100 }],
+            }),
+        ]);
+        expect(card.body[0]).toMatchObject({
+            type: "Chart.Line",
+            data: [{ legend: "Revenue", values: [{ x: "Q1", y: 100 }] }],
+        });
+    });
+    it("maps horizontalBar to an x/y series", () => {
+        const card = renderAdaptiveCard([
+            chart({ type: "horizontalBar", data: [{ label: "A", value: 5 }] }),
+        ]);
+        expect(card.body[0]).toMatchObject({
+            type: "Chart.HorizontalBar",
+            data: [{ x: "A", y: 5 }],
+        });
+    });
+    it("clamps chart data points to the Teams ceiling", () => {
+        const data = Array.from({ length: 80 }, (_, i) => ({
+            label: `p${i}`,
+            value: i,
+        }));
+        const card = renderAdaptiveCard([chart({ data })]);
+        const points = card.body[0].data;
+        expect(points).toHaveLength(50);
+    });
+});
+describe("isPlainText", () => {
+    it("is true for text-only trees", () => {
+        expect(isPlainText([text("hi")])).toBe(true);
+        expect(isPlainText([el("message", [el("section", [text("hi")])])])).toBe(true);
+    });
+    it("is false once any rich element appears", () => {
+        expect(isPlainText([el("header", [text("hi")])])).toBe(false);
+        expect(isPlainText([el("actions", [el("button", [text("x")])])])).toBe(false);
+        expect(isPlainText([el("message", [chart({ data: [] })])])).toBe(false);
+    });
+});
+describe("collectPlainText", () => {
+    it("joins block text depth-first", () => {
+        const ir = [el("message", [el("section", [text("a")]), text("b")])];
+        expect(collectPlainText(ir)).toBe("ab");
+    });
+});

package/dist/render/auto-close.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Streaming-polish layer for Teams' post-then-edit streaming.
+ *
+ * While an agent is mid-stream the buffer is usually an *unfinished* markdown
+ * document: an open code fence, an unclosed `**`, etc. Teams renders message
+ * text as markdown, so editing the message with unbalanced text makes the rest
+ * of the bubble render broken (a stray ``` turns the remainder into a code
+ * block until the closer arrives, a dangling `**` bolds the rest, and so on).
+ *
+ * `autoCloseOpenMarkdown` returns a balanced copy of the buffer by appending the
+ * minimum set of closers needed for well-formed display. When the agent later
+ * emits the real closer the buffer balances on its own and this adds nothing,
+ * so the *committed* (finalized) message has no synthetic closers.
+ *
+ * Handled, in priority order:
+ *   1. Unclosed fenced code blocks ``` (most severe: leaks code styling)
+ *   2. Unclosed inline code
+ *   3. Unclosed bold `**` / `__`, italic `*` / `_`, strike `~~`
+ *
+ * Heuristics:
+ *   - A marker with no content after it (trailing `**`) is NOT closed. The
+ *     agent may just be opening it; closing would flash a transient `****`.
+ *   - Markers inside code/fence regions don't count.
+ *   - Closers are emitted innermost-first so the structure nests correctly.
+ */
+export declare function autoCloseOpenMarkdown(text: string): string;
+//# sourceMappingURL=auto-close.d.ts.map

package/dist/render/auto-close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-close.d.ts","sourceRoot":"","sources":["../../src/render/auto-close.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAOH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkE1D"}