@fusion.dev/helix-headless 0.215.3 → 0.216.0

package/dist/markdown/blocks.js

@@ -0,0 +1,326 @@
+const BLANK = /^[ \t]*$/;
+const FENCE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/;
+const RULE = /^ {0,3}(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const QUOTE = /^ {0,3}> ?/;
+const MARKER = /^( {0,3})([-+*]|(\d{1,9})([.)]))(?=[ \t]|$)([ \t]*)(.*)$/;
+const DELIMITER = /^:?-+:?$/;
+const ALERT = /^\[!(caution|important|note|tip|warning)\][ \t]*$/i;
+const TASK = /^\[([ xX])\](?:[ \t]+|$)/;
+const blank = (line) => BLANK.test(line);
+export const indentOf = (line) => {
+    let columns = 0;
+    for (const character of line) {
+        if (character === ' ') {
+            columns += 1;
+        }
+        else if (character === '\t') {
+            columns += 4 - (columns % 4);
+        }
+        else {
+            break;
+        }
+    }
+    return columns;
+};
+const stripIndent = (line, columns) => {
+    let taken = 0;
+    let at = 0;
+    while (at < line.length && taken < columns) {
+        const character = line[at];
+        if (character === ' ') {
+            taken += 1;
+        }
+        else if (character === '\t') {
+            const width = 4 - (taken % 4);
+            if (taken + width > columns) {
+                return ' '.repeat(taken + width - columns) + line.slice(at + 1);
+            }
+            taken += width;
+        }
+        else {
+            break;
+        }
+        at += 1;
+    }
+    return line.slice(at);
+};
+const markerOf = (line) => {
+    const match = MARKER.exec(line);
+    if (!match) {
+        return undefined;
+    }
+    const [, lead = '', marker = '', digits, delimiter, gap = '', rest = ''] = match;
+    const width = lead.length + marker.length;
+    const spaces = indentOf(`${' '.repeat(width)}${gap}`) - width;
+    const content = rest === '' || spaces > 4 ? width + 1 : width + spaces;
+    return {
+        bullet: delimiter ?? marker,
+        content,
+        number: digits === undefined ? undefined : Number(digits),
+        rest: spaces > 4 ? `${' '.repeat(spaces - 1)}${rest}` : rest,
+    };
+};
+export const cellsOf = (line) => {
+    let row = line.trim();
+    if (row.startsWith('|')) {
+        row = row.slice(1);
+    }
+    if (row.endsWith('|') && !row.endsWith('\\|')) {
+        row = row.slice(0, -1);
+    }
+    const cells = [];
+    let cell = '';
+    for (let at = 0; at < row.length; at += 1) {
+        const character = row[at];
+        if (character === '\\' && row[at + 1] === '|') {
+            cell += '|';
+            at += 1;
+        }
+        else if (character === '|') {
+            cells.push(cell.trim());
+            cell = '';
+        }
+        else {
+            cell += character;
+        }
+    }
+    cells.push(cell.trim());
+    return cells;
+};
+const delimiterOf = (line, count) => {
+    if (line === undefined || !line.includes('-') || indentOf(line) > 3) {
+        return undefined;
+    }
+    const cells = cellsOf(line);
+    if (cells.length !== count || !cells.every((cell) => DELIMITER.test(cell))) {
+        return undefined;
+    }
+    return cells.map((cell) => {
+        const left = cell.startsWith(':');
+        const right = cell.endsWith(':');
+        return left && right ? 'center' : right ? 'end' : left ? 'start' : undefined;
+    });
+};
+const startsTable = (line, next) => line.includes('|') && indentOf(line) < 4 && delimiterOf(next, cellsOf(line).length) !== undefined;
+const interrupts = (line) => {
+    if (indentOf(line) > 3) {
+        return false;
+    }
+    if (FENCE.test(line) || HEADING.test(line) || RULE.test(line) || QUOTE.test(line)) {
+        return true;
+    }
+    const marker = markerOf(line);
+    return marker !== undefined && marker.rest.trim() !== '' && (marker.number ?? 1) === 1;
+};
+const endsInParagraph = (blocks) => {
+    const last = blocks.at(-1);
+    if (last?.kind === 'paragraph') {
+        return true;
+    }
+    if (last?.kind === 'quote') {
+        return endsInParagraph(last.children);
+    }
+    if (last?.kind === 'list') {
+        return endsInParagraph(last.items.at(-1)?.children ?? []);
+    }
+    return false;
+};
+const lazy = (inner, line, next) => !blank(line) &&
+    !interrupts(line) &&
+    !startsTable(line, next) &&
+    inner.length > 0 &&
+    !blank(inner.at(-1) ?? '') &&
+    endsInParagraph(parseBlocks(inner).blocks);
+const readFence = (lines, at) => {
+    const match = FENCE.exec(lines[at] ?? '');
+    const indent = (match[1] ?? '').length;
+    const fence = match[2] ?? '```';
+    const info = (match[3] ?? '').trim();
+    const closing = new RegExp(`^ {0,3}${fence[0] === '`' ? '`' : '~'}{${fence.length},}[ \\t]*$`);
+    const body = [];
+    let line = at + 1;
+    let open = true;
+    while (line < lines.length) {
+        const text = lines[line] ?? '';
+        line += 1;
+        if (closing.test(text)) {
+            open = false;
+            break;
+        }
+        body.push(stripIndent(text, indent));
+    }
+    return [{ info, kind: 'code', open, text: body.join('\n') }, line];
+};
+const readQuote = (lines, at) => {
+    const inner = [];
+    let line = at;
+    while (line < lines.length) {
+        const text = lines[line] ?? '';
+        const marker = QUOTE.exec(text);
+        if (marker && indentOf(text) < 4) {
+            inner.push(text.slice(marker[0].length));
+        }
+        else if (lazy(inner, text, lines[line + 1])) {
+            inner.push(text);
+        }
+        else {
+            break;
+        }
+        line += 1;
+    }
+    const children = parseBlocks(inner).blocks;
+    const first = children[0];
+    const firstLine = first?.kind === 'paragraph' ? (first.text.split('\n')[0] ?? '') : '';
+    const alert = ALERT.exec(firstLine.trim());
+    if (alert && first?.kind === 'paragraph') {
+        const rest = first.text.split('\n').slice(1).join('\n');
+        return [
+            {
+                alert: (alert[1] ?? 'note').toLowerCase(),
+                children: rest.trim() === ''
+                    ? children.slice(1)
+                    : [{ kind: 'paragraph', text: rest }, ...children.slice(1)],
+                kind: 'quote',
+            },
+            line,
+        ];
+    }
+    return [{ children, kind: 'quote' }, line];
+};
+const readList = (lines, at) => {
+    const first = markerOf(lines[at] ?? '');
+    const ordered = first.number !== undefined;
+    const items = [];
+    let line = at;
+    while (line < lines.length) {
+        const marker = markerOf(lines[line] ?? '');
+        if (!marker || marker.bullet !== first.bullet || indentOf(lines[line] ?? '') > 3) {
+            break;
+        }
+        const inner = [marker.rest];
+        line += 1;
+        while (line < lines.length) {
+            const text = lines[line] ?? '';
+            if (blank(text)) {
+                let ahead = line;
+                while (ahead < lines.length && blank(lines[ahead] ?? '')) {
+                    ahead += 1;
+                }
+                if (ahead < lines.length && indentOf(lines[ahead] ?? '') >= marker.content) {
+                    inner.push('');
+                    line += 1;
+                    continue;
+                }
+                break;
+            }
+            if (indentOf(text) >= marker.content) {
+                inner.push(stripIndent(text, marker.content));
+            }
+            else if (!markerOf(text) && lazy(inner, text, lines[line + 1])) {
+                inner.push(text);
+            }
+            else {
+                break;
+            }
+            line += 1;
+        }
+        const task = TASK.exec(inner[0] ?? '');
+        if (task) {
+            inner[0] = (inner[0] ?? '').slice(task[0].length);
+        }
+        const item = { children: parseBlocks(inner).blocks };
+        if (task) {
+            item.checked = task[1] !== ' ';
+        }
+        items.push(item);
+        let ahead = line;
+        while (ahead < lines.length && blank(lines[ahead] ?? '')) {
+            ahead += 1;
+        }
+        const next = markerOf(lines[ahead] ?? '');
+        if (ahead === line || !next || next.bullet !== first.bullet) {
+            if (ahead === line) {
+                continue;
+            }
+            break;
+        }
+        line = ahead;
+    }
+    return [{ items, kind: 'list', ordered, start: first.number ?? 1 }, line];
+};
+const readTable = (lines, at) => {
+    const head = cellsOf(lines[at] ?? '');
+    const align = delimiterOf(lines[at + 1], head.length) ?? [];
+    const rows = [];
+    let line = at + 2;
+    while (line < lines.length) {
+        const text = lines[line] ?? '';
+        if (blank(text) || interrupts(text)) {
+            break;
+        }
+        const cells = cellsOf(text);
+        rows.push(head.map((_, column) => cells[column] ?? ''));
+        line += 1;
+    }
+    return [{ align, head, kind: 'table', rows }, line];
+};
+const readParagraph = (lines, at) => {
+    const body = [(lines[at] ?? '').replace(/^[ \t]+/, '')];
+    let line = at + 1;
+    while (line < lines.length) {
+        const text = lines[line] ?? '';
+        if (blank(text) || interrupts(text) || startsTable(text, lines[line + 1])) {
+            break;
+        }
+        body.push(text.replace(/^[ \t]+/, ''));
+        line += 1;
+    }
+    return [{ kind: 'paragraph', text: body.join('\n').replace(/[ \t]+$/, '') }, line];
+};
+export const parseBlocks = (lines) => {
+    const blocks = [];
+    const starts = [];
+    let line = 0;
+    while (line < lines.length) {
+        const text = lines[line] ?? '';
+        if (blank(text)) {
+            line += 1;
+            continue;
+        }
+        starts.push(line);
+        let read;
+        if (indentOf(text) > 3) {
+            read = readParagraph(lines, line);
+        }
+        else if (FENCE.test(text) &&
+            !(text.trimStart().startsWith('`') && /`/.test(FENCE.exec(text)?.[3] ?? ''))) {
+            read = readFence(lines, line);
+        }
+        else if (HEADING.test(text)) {
+            const match = HEADING.exec(text);
+            read = [
+                { kind: 'heading', level: (match[1] ?? '#').length, text: (match[2] ?? '').trim() },
+                line + 1,
+            ];
+        }
+        else if (RULE.test(text)) {
+            read = [{ kind: 'rule' }, line + 1];
+        }
+        else if (QUOTE.test(text)) {
+            read = readQuote(lines, line);
+        }
+        else if (markerOf(text)) {
+            read = readList(lines, line);
+        }
+        else if (startsTable(text, lines[line + 1])) {
+            read = readTable(lines, line);
+        }
+        else {
+            read = readParagraph(lines, line);
+        }
+        blocks.push(read[0]);
+        line = read[1];
+    }
+    return { blocks, starts };
+};

package/dist/markdown/index.d.ts

@@ -0,0 +1,6 @@
+export type { MarkdownAlertKind, MarkdownAlign, MarkdownBlock, MarkdownItem } from './blocks.js';
+export { type InlineOptions, type MarkdownInline, parseInline } from './inline.js';
+export * from './root/markdown-root.js';
+export { type MarkdownRead, MarkdownStream, visibleText } from './stream.js';
+export { type MarkdownElement, type MarkdownNode, type MarkdownOptions, type MarkdownTags, markdownNodes, markdownToHtml, safeUrl, } from './tree.js';
+export { MarkdownWriter } from './writer.js';

package/dist/markdown/index.js

@@ -0,0 +1,5 @@
+export { parseInline } from './inline.js';
+export * from './root/markdown-root.js';
+export { MarkdownStream, visibleText } from './stream.js';
+export { markdownNodes, markdownToHtml, safeUrl, } from './tree.js';
+export { MarkdownWriter } from './writer.js';

package/dist/markdown/inline.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Markdown's inline marks: code, emphasis, strong, strikethrough, links,
+ * images, autolinks, and line breaks, by CommonMark's delimiter rules and
+ * GitHub's extensions.
+ *
+ * **An open block is read as if it ended where the text so far ends.** While a
+ * reply streams, the last block is still arriving, and reading `**bold` as
+ * two asterisks would draw them and then take them back when the closing pair
+ * arrives, moving every word after them. So in an open block:
+ *
+ * - an opening delimiter with no closer yet is drawn as if it closed at the end,
+ * - a delimiter run, a backslash, a `!`, or part of an entity or an autolink at
+ *   the very end is held back, since the next character decides what it is,
+ * - a code span with no closing backticks yet runs to the end,
+ * - a link whose `]` or `)` has not arrived drops its brackets and its address
+ *   and draws its text as a link with no address yet.
+ *
+ * Once a block closes it is read strictly, so a mark that never closed is
+ * drawn as the characters it is. That is the one change a closed block can
+ * see, and only text that was never valid Markdown makes it.
+ */
+/** An inline node. */
+export type MarkdownInline = {
+    kind: 'break';
+} | {
+    kind: 'code';
+    text: string;
+} | {
+    children: MarkdownInline[];
+    kind: 'del' | 'em' | 'strong';
+} | {
+    alt: string;
+    kind: 'image';
+    src: string;
+    title?: string;
+} | {
+    children: MarkdownInline[];
+    href?: string;
+    kind: 'link';
+    title?: string;
+} | {
+    kind: 'text';
+    text: string;
+};
+/** How the text is read: strictly, or as the open end of a block still arriving. */
+export interface InlineOptions {
+    open?: boolean | undefined;
+}
+/**
+ * The text's inline nodes.
+ *
+ * With `open`, the end of the text is read as the end of a block still
+ * arriving, as the module's description sets out.
+ */
+export declare const parseInline: (text: string, options?: InlineOptions) => MarkdownInline[];
+/** The plain text of some inline nodes, as an image's alternative text reads it. */
+export declare const textOf: (nodes: MarkdownInline[]) => string;