poe-code 3.0.181 → 3.0.183

package/packages/design-system/dist/terminal-markdown/parser/frontmatter.d.ts

@@ -1,6 +1,8 @@
+import type { MdRange } from "../ast.js";
 type ExtractedFrontmatter = {
     frontmatter?: Record<string, unknown>;
     body: string;
+    range?: MdRange;
 };
 export declare function extractFrontmatter(markdown: string): ExtractedFrontmatter;
 export {};

package/packages/design-system/dist/terminal-markdown/parser/frontmatter.js

@@ -100,22 +100,24 @@ class YamlSubsetParser {
     }
 }
 export function extractFrontmatter(markdown) {
-    const content = stripBom(markdown);
-    if (!startsWithFrontmatterFence(content)) {
+    if (!startsWithFrontmatterFence(markdown)) {
+        return { body: markdown };
+    }
+    const openingLine = readLine(markdown, 0);
+    if (stripBom(openingLine.text) !== "---") {
         return { body: markdown };
     }
-    const openingLine = readLine(content, 0);
     let position = openingLine.nextPosition;
     let closingFenceStart;
     let closingFenceNextPosition;
-    while (position <= content.length) {
-        const line = readLine(content, position);
+    while (position <= markdown.length) {
+        const line = readLine(markdown, position);
         if (line.text === "---") {
             closingFenceStart = line.start;
             closingFenceNextPosition = line.nextPosition;
             break;
         }
-        if (line.nextPosition >= content.length) {
+        if (line.nextPosition >= markdown.length) {
             break;
         }
         position = line.nextPosition;
@@ -123,12 +125,15 @@ export function extractFrontmatter(markdown) {
     if (closingFenceStart === undefined || closingFenceNextPosition === undefined) {
         return { body: markdown };
     }
-    const rawFrontmatter = sliceFrontmatterBlock(content, openingLine.nextPosition, closingFenceStart);
+    const rawFrontmatter = sliceFrontmatterBlock(markdown, openingLine.nextPosition, closingFenceStart);
     const frontmatter = parseFrontmatterBlock(rawFrontmatter);
-    return {
+    return withRange({
         frontmatter,
-        body: content.slice(closingFenceNextPosition)
-    };
+        body: markdown.slice(closingFenceNextPosition)
+    }, {
+        start: 0,
+        end: Buffer.byteLength(markdown.slice(0, closingFenceNextPosition), "utf8")
+    });
 }
 function parseFrontmatterBlock(yamlBlock) {
     if (yamlBlock.length === 0) {
@@ -338,11 +343,23 @@ function sliceFrontmatterBlock(content, start, end) {
     return content.slice(start, sliceEnd);
 }
 function startsWithFrontmatterFence(value) {
-    return value.startsWith("---\n") || value.startsWith("---\r\n");
+    return (value.startsWith("---\n") ||
+        value.startsWith("---\r\n") ||
+        value.startsWith("\uFEFF---\n") ||
+        value.startsWith("\uFEFF---\r\n"));
 }
 function stripBom(value) {
     return value.startsWith("\uFEFF") ? value.slice(1) : value;
 }
+function withRange(value, range) {
+    Object.defineProperty(value, "range", {
+        value: range,
+        enumerable: false,
+        configurable: true,
+        writable: true
+    });
+    return value;
+}
 function readLine(input, position) {
     let end = position;
     while (end < input.length && input[end] !== "\n" && input[end] !== "\r") {

package/packages/design-system/dist/terminal-markdown/parser/inline.d.ts

@@ -1,6 +1,10 @@
 import type { MdNode } from "../ast.js";
+type OffsetMap = readonly number[];
 export type ParseInlineOptions = {
     footnoteLabels?: ReadonlySet<string>;
     allowLiteralAutolinks?: boolean;
+    offset?: number;
+    offsets?: OffsetMap;
 };
 export declare function parseInline(raw: string, options?: ParseInlineOptions): MdNode[];
+export {};

package/packages/design-system/dist/terminal-markdown/parser/inline.js

@@ -96,24 +96,32 @@ export function parseInline(raw, options = {}) {
     const delimiters = [];
     const footnoteLabels = options.footnoteLabels;
     const allowLiteralAutolinks = options.allowLiteralAutolinks ?? true;
+    const offsets = options.offsets ?? createOffsetMap(raw, options.offset ?? 0);
     let textBuffer = "";
+    let textStart = 0;
     let index = 0;
-    const flushText = () => {
+    const appendText = (value, start) => {
+        if (textBuffer.length === 0) {
+            textStart = start;
+        }
+        textBuffer += value;
+    };
+    const flushText = (end = index) => {
         if (textBuffer.length === 0) {
             return;
         }
-        nodes.push({ type: "text", value: textBuffer });
+        nodes.push(createTextNode(textBuffer, createRange(offsets, textStart, end)));
         textBuffer = "";
     };
     while (index < raw.length) {
         const char = raw[index];
         if (char === "\\" && index + 1 < raw.length && isEscapable(raw[index + 1])) {
-            textBuffer += raw[index + 1];
+            appendText(raw[index + 1], index);
             index += 2;
             continue;
         }
         if (char === "`") {
-            const code = parseInlineCode(raw, index);
+            const code = parseInlineCode(raw, index, offsets);
             if (code !== null) {
                 flushText();
                 nodes.push(code.node);
@@ -122,7 +130,7 @@ export function parseInline(raw, options = {}) {
             }
         }
         if (char === "!" && index + 1 < raw.length && raw[index + 1] === "[") {
-            const image = parseImage(raw, index);
+            const image = parseImage(raw, index, offsets);
             if (image !== null) {
                 flushText();
                 nodes.push(image.node);
@@ -131,14 +139,14 @@ export function parseInline(raw, options = {}) {
             }
         }
         if (char === "[") {
-            const footnoteReference = parseFootnoteReference(raw, index, footnoteLabels);
+            const footnoteReference = parseFootnoteReference(raw, index, footnoteLabels, offsets);
             if (footnoteReference !== null) {
                 flushText();
                 nodes.push(footnoteReference.node);
                 index = footnoteReference.end;
                 continue;
             }
-            const link = parseLink(raw, index, footnoteLabels);
+            const link = parseLink(raw, index, footnoteLabels, offsets);
             if (link !== null) {
                 flushText();
                 nodes.push(link.node);
@@ -147,14 +155,14 @@ export function parseInline(raw, options = {}) {
             }
         }
         if (char === "<") {
-            const autolink = parseAutolink(raw, index);
+            const autolink = parseAutolink(raw, index, offsets);
             if (autolink !== null) {
                 flushText();
                 nodes.push(autolink.node);
                 index = autolink.end;
                 continue;
             }
-            const html = parseInlineHtmlTag(raw, index);
+            const html = parseInlineHtmlTag(raw, index, offsets);
             if (html !== null) {
                 flushText();
                 nodes.push(html.node);
@@ -165,22 +173,23 @@ export function parseInline(raw, options = {}) {
         if (char === "\n") {
             if (textBuffer.endsWith("\\")) {
                 textBuffer = textBuffer.slice(0, -1);
-                flushText();
-                nodes.push({ type: "break" });
+                flushText(index - 1);
+                nodes.push(withRange({ type: "break" }, createRange(offsets, index, index + 1)));
                 index += 1;
                 continue;
             }
             const trailingSpaceStart = findTrailingHardBreakSpaceStart(textBuffer);
             if (trailingSpaceStart !== -1) {
+                const trailingSpaceCount = textBuffer.length - trailingSpaceStart;
                 textBuffer = textBuffer.slice(0, trailingSpaceStart);
-                flushText();
-                nodes.push({ type: "break" });
+                flushText(index - trailingSpaceCount);
+                nodes.push(withRange({ type: "break" }, createRange(offsets, index, index + 1)));
                 index += 1;
                 continue;
             }
         }
         if (allowLiteralAutolinks) {
-            const literalAutolink = parseLiteralAutolink(raw, index);
+            const literalAutolink = parseLiteralAutolink(raw, index, offsets);
             if (literalAutolink !== null) {
                 flushText();
                 nodes.push(literalAutolink.node);
@@ -192,10 +201,10 @@ export function parseInline(raw, options = {}) {
             const delimiter = parseDelimiter(raw, index, char);
             if (delimiter !== null) {
                 flushText();
-                const node = {
-                    type: "text",
-                    value: raw.slice(index, index + delimiter.length)
-                };
+                const node = createTextNode(raw.slice(index, index + delimiter.length), {
+                    start: offsets[index] ?? 0,
+                    end: offsets[index + delimiter.length] ?? offsets[offsets.length - 1] ?? 0
+                });
                 nodes.push(node);
                 delimiters.push({
                     ...delimiter,
@@ -206,7 +215,7 @@ export function parseInline(raw, options = {}) {
                 continue;
             }
         }
-        textBuffer += char;
+        appendText(char, index);
         index += 1;
     }
     flushText();
@@ -407,14 +416,14 @@ function buildInlineNodes(nodes, delimiters, pairs) {
             }
         }
         if (delimiterEntry.delimiter.length > 0) {
-            appendNode({
-                type: "text",
-                value: delimiterEntry.delimiter.marker.repeat(delimiterEntry.delimiter.length)
-            });
+            appendNode(createTextNode(delimiterEntry.delimiter.marker.repeat(delimiterEntry.delimiter.length), node.range));
         }
         delimiterEntry.opens.sort((left, right) => right.sequence - left.sequence);
         for (const pair of delimiterEntry.opens) {
-            const wrapper = createDelimiterNode(pair.kind);
+            const wrapper = withRange(createDelimiterNode(pair.kind), {
+                start: pair.opener.node.range?.start ?? pair.opener.position,
+                end: pair.closer.node.range?.end ?? pair.closer.position
+            });
             appendNode(wrapper);
             stack.push({ pair, children: wrapper.children });
         }
@@ -424,6 +433,30 @@ function buildInlineNodes(nodes, delimiters, pairs) {
 function createDelimiterNode(kind) {
     return { type: kind, children: [] };
 }
+function createTextNode(value, range) {
+    return range === undefined ? { type: "text", value } : withRange({ type: "text", value }, range);
+}
+function withRange(node, range) {
+    Object.defineProperty(node, "range", {
+        value: range,
+        enumerable: false,
+        configurable: true,
+        writable: true
+    });
+    return node;
+}
+function mergeRanges(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    if (right === undefined) {
+        return left;
+    }
+    return {
+        start: Math.min(left.start, right.start),
+        end: Math.max(left.end, right.end)
+    };
+}
 function normalizeInlineNodes(nodes) {
     const normalized = [];
     for (const node of nodes) {
@@ -434,6 +467,10 @@ function normalizeInlineNodes(nodes) {
         const previousNode = normalized[normalized.length - 1];
         if (previousNode?.type === "text" && nextNode.type === "text") {
             previousNode.value += nextNode.value;
+            const range = mergeRanges(previousNode.range, nextNode.range);
+            if (range !== undefined) {
+                withRange(previousNode, range);
+            }
             continue;
         }
         normalized.push(nextNode);
@@ -448,11 +485,12 @@ function normalizeInlineNode(node) {
         node.type === "strong" ||
         node.type === "strikethrough" ||
         node.type === "link") {
-        return { ...node, children: normalizeInlineNodes(node.children) };
+        const nextNode = { ...node, children: normalizeInlineNodes(node.children) };
+        return node.range === undefined ? nextNode : withRange(nextNode, node.range);
     }
     return node;
 }
-function parseInlineCode(input, start) {
+function parseInlineCode(input, start, offsets) {
     const fenceLength = readRunLength(input, start, "`");
     let index = start + fenceLength;
     while (index < input.length) {
@@ -463,10 +501,15 @@ function parseInlineCode(input, start) {
         const closingFenceLength = readRunLength(input, index, "`");
         if (closingFenceLength === fenceLength) {
             return {
-                node: {
-                    type: "inlineCode",
-                    value: input.slice(start + fenceLength, index)
-                },
+                node: offsets === undefined
+                    ? {
+                        type: "inlineCode",
+                        value: input.slice(start + fenceLength, index)
+                    }
+                    : withRange({
+                        type: "inlineCode",
+                        value: input.slice(start + fenceLength, index)
+                    }, createRange(offsets, start, index + fenceLength)),
                 end: index + fenceLength
             };
         }
@@ -474,7 +517,7 @@ function parseInlineCode(input, start) {
     }
     return null;
 }
-function parseLink(input, start, footnoteLabels) {
+function parseLink(input, start, footnoteLabels, offsets) {
     const label = parseBracketedLabel(input, start);
     if (label === null || label.end >= input.length || input[label.end] !== "(") {
         return null;
@@ -484,19 +527,22 @@ function parseLink(input, start, footnoteLabels) {
         return null;
     }
     return {
-        node: {
+        node: withRange({
             type: "link",
             url: destination.url,
             ...(destination.title === undefined ? {} : { title: destination.title }),
             children: parseInline(label.value, {
                 footnoteLabels,
-                allowLiteralAutolinks: false
+                allowLiteralAutolinks: false,
+                ...(offsets === undefined
+                    ? {}
+                    : { offsets: sliceOffsetMap(offsets, label.contentStart, label.end - 1) })
             })
-        },
+        }, offsets === undefined ? { start, end: destination.end } : createRange(offsets, start, destination.end)),
         end: destination.end
     };
 }
-function parseImage(input, start) {
+function parseImage(input, start, offsets) {
     const label = parseBracketedLabel(input, start + 1);
     if (label === null || label.end >= input.length || input[label.end] !== "(") {
         return null;
@@ -506,12 +552,12 @@ function parseImage(input, start) {
         return null;
     }
     return {
-        node: {
+        node: withRange({
             type: "image",
             url: destination.url,
             alt: decodeEscapes(label.value),
             ...(destination.title === undefined ? {} : { title: destination.title })
-        },
+        }, offsets === undefined ? { start, end: destination.end } : createRange(offsets, start, destination.end)),
         end: destination.end
     };
 }
@@ -544,6 +590,7 @@ function parseBracketedLabel(input, start) {
             if (depth === 0) {
                 return {
                     value: input.slice(start + 1, index),
+                    contentStart: start + 1,
                     end: index + 1
                 };
             }
@@ -631,7 +678,7 @@ function findTrailingQuotedSegmentStart(content, end, quote) {
     }
     return -1;
 }
-function parseAutolink(input, start) {
+function parseAutolink(input, start, offsets) {
     let index = start + 1;
     while (index < input.length && input[index] !== ">") {
         const char = input[index];
@@ -648,15 +695,17 @@ function parseAutolink(input, start) {
         return null;
     }
     return {
-        node: {
+        node: withRange({
             type: "link",
             url,
-            children: [{ type: "text", value: url }]
-        },
+            children: [
+                createTextNode(url, offsets === undefined ? { start: start + 1, end: index } : createRange(offsets, start + 1, index))
+            ]
+        }, offsets === undefined ? { start, end: index + 1 } : createRange(offsets, start, index + 1)),
         end: index + 1
     };
 }
-function parseFootnoteReference(input, start, footnoteLabels) {
+function parseFootnoteReference(input, start, footnoteLabels, offsets) {
     if (footnoteLabels === undefined ||
         start + 3 >= input.length ||
         input[start] !== "[" ||
@@ -678,35 +727,35 @@ function parseFootnoteReference(input, start, footnoteLabels) {
         return null;
     }
     return {
-        node: { type: "footnoteReference", label },
+        node: withRange({ type: "footnoteReference", label }, offsets === undefined ? { start, end: labelEnd + 1 } : createRange(offsets, start, labelEnd + 1)),
         end: labelEnd + 1
     };
 }
-function parseLiteralAutolink(input, start) {
+function parseLiteralAutolink(input, start, offsets) {
     if (!isLiteralAutolinkBoundaryBefore(input, start)) {
         return null;
     }
     const urlLiteral = parseLiteralUrlAutolink(input, start);
     if (urlLiteral !== null) {
-        return createLiteralAutolinkNode(urlLiteral.text, urlLiteral.url, urlLiteral.end);
+        return createLiteralAutolinkNode(urlLiteral.text, urlLiteral.url, start, urlLiteral.end, offsets);
     }
     const wwwLiteral = parseLiteralWwwAutolink(input, start);
     if (wwwLiteral !== null) {
-        return createLiteralAutolinkNode(wwwLiteral.text, `http://${wwwLiteral.text}`, wwwLiteral.end);
+        return createLiteralAutolinkNode(wwwLiteral.text, `http://${wwwLiteral.text}`, start, wwwLiteral.end, offsets);
     }
     const emailLiteral = parseLiteralEmailAutolink(input, start);
     if (emailLiteral !== null) {
-        return createLiteralAutolinkNode(emailLiteral.text, `mailto:${emailLiteral.text}`, emailLiteral.end);
+        return createLiteralAutolinkNode(emailLiteral.text, `mailto:${emailLiteral.text}`, start, emailLiteral.end, offsets);
     }
     return null;
 }
-function createLiteralAutolinkNode(text, url, end) {
+function createLiteralAutolinkNode(text, url, start, end, offsets) {
     return {
-        node: {
+        node: withRange({
             type: "link",
             url,
-            children: [{ type: "text", value: text }]
-        },
+            children: [createTextNode(text, offsets === undefined ? { start, end } : createRange(offsets, start, end))]
+        }, offsets === undefined ? { start, end } : createRange(offsets, start, end)),
         end
     };
 }
@@ -746,7 +795,7 @@ function parseLiteralEmailAutolink(input, start) {
     }
     return { text, end: start + text.length };
 }
-function parseInlineHtmlTag(input, start) {
+function parseInlineHtmlTag(input, start, offsets) {
     if (input[start] !== "<") {
         return null;
     }
@@ -773,7 +822,7 @@ function parseInlineHtmlTag(input, start) {
             return null;
         }
         return {
-            node: { type: "html", value: input.slice(start, index + 1) },
+            node: withRange({ type: "html", value: input.slice(start, index + 1) }, offsets === undefined ? { start, end: index + 1 } : createRange(offsets, start, index + 1)),
             end: index + 1
         };
     }
@@ -784,7 +833,7 @@ function parseInlineHtmlTag(input, start) {
         }
         if (input[index] === ">") {
             return {
-                node: { type: "html", value: input.slice(start, index + 1) },
+                node: withRange({ type: "html", value: input.slice(start, index + 1) }, offsets === undefined ? { start, end: index + 1 } : createRange(offsets, start, index + 1)),
                 end: index + 1
             };
         }
@@ -794,7 +843,9 @@ function parseInlineHtmlTag(input, start) {
                 return null;
             }
             return {
-                node: { type: "html", value: input.slice(start, selfClosingEnd + 1) },
+                node: withRange({ type: "html", value: input.slice(start, selfClosingEnd + 1) }, offsets === undefined
+                    ? { start, end: selfClosingEnd + 1 }
+                    : createRange(offsets, start, selfClosingEnd + 1)),
                 end: selfClosingEnd + 1
             };
         }
@@ -1085,3 +1136,31 @@ function isHtmlAttributeNameChar(value) {
         value === "-" ||
         value === ".");
 }
+function createRange(offsets, start, end) {
+    return {
+        start: offsets[start] ?? offsets[offsets.length - 1] ?? 0,
+        end: offsets[end] ?? offsets[offsets.length - 1] ?? 0
+    };
+}
+function sliceOffsetMap(offsets, start, end) {
+    return offsets.slice(start, end + 1);
+}
+function createOffsetMap(input, absoluteStart = 0) {
+    const offsets = new Array(input.length + 1).fill(absoluteStart);
+    let byteOffset = absoluteStart;
+    let index = 0;
+    while (index < input.length) {
+        offsets[index] = byteOffset;
+        const codePoint = input.codePointAt(index) ?? 0;
+        const codeUnitLength = codePoint > 0xffff ? 2 : 1;
+        const byteLength = codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+        for (let offsetIndex = 1; offsetIndex < codeUnitLength; offsetIndex += 1) {
+            offsets[index + offsetIndex] = byteOffset;
+        }
+        byteOffset += byteLength;
+        index += codeUnitLength;
+        offsets[index] = byteOffset;
+    }
+    offsets[input.length] = byteOffset;
+    return offsets;
+}

package/packages/design-system/dist/terminal-markdown/parser.js

@@ -1,13 +1,42 @@
 import { parseBlockDocument } from "./parser/block.js";
 export function parse(markdown) {
-    const { frontmatter, children } = parseBlockDocument(markdown);
+    const { frontmatter, frontmatterRange, children } = parseBlockDocument(markdown);
+    const ast = withRange({
+        type: "root",
+        children: frontmatter === undefined
+            ? children
+            : [createFrontmatterNode(frontmatter, frontmatterRange), ...children]
+    }, {
+        start: 0,
+        end: Buffer.byteLength(markdown, "utf8")
+    });
     return {
         ...(frontmatter === undefined ? {} : { frontmatter }),
-        ast: {
-            type: "root",
-            children: frontmatter === undefined
-                ? children
-                : [{ type: "frontmatter", data: frontmatter }, ...children]
-        }
+        ast
     };
 }
+function createFrontmatterNode(data, range) {
+    const node = {
+        type: "frontmatter",
+        data
+    };
+    if (range === undefined) {
+        return node;
+    }
+    Object.defineProperty(node, "range", {
+        value: range,
+        enumerable: false,
+        configurable: true,
+        writable: true
+    });
+    return node;
+}
+function withRange(node, range) {
+    Object.defineProperty(node, "range", {
+        value: range,
+        enumerable: false,
+        configurable: true,
+        writable: true
+    });
+    return node;
+}