@texuli/blocks 0.0.0-stage → 0.1.0-next.0

package/dist/text/markdown.js

@@ -0,0 +1,361 @@
+import { safeHref } from '@texuli/core';
+/** Nesting and size caps: hostile input degrades to literal text, never recursion blowups. */
+export const MARKDOWN_LIMITS = /* @__PURE__ */ Object.freeze({
+    /**
+     * Longest source parsed, equal to the schema's markdown cap. Pathological
+     * inline input stays under ~50 ms at this size.
+     */
+    source: 4_000,
+    /** Nested quotes and lists. */
+    blockDepth: 4,
+    /** Nested emphasis and links. */
+    inlineDepth: 6,
+});
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([a-z][a-z0-9+-]{0,31})?\s*$/i;
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*#*[ \t]*$/;
+const RULE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+const QUOTE = /^ {0,3}> ?(.*)$/;
+const BULLET = /^( {0,3})([-*+])[ \t]+(.*)$/;
+const ORDERED = /^( {0,3})(\d{1,9})[.)][ \t]+(.*)$/;
+const TASK = /^\[([ xX])\][ \t]+/;
+/** Parses validated block text into the closed Markdown tree. */
+export function parseMarkdown(source) {
+    const text = String(source).slice(0, MARKDOWN_LIMITS.source).replace(/\r\n?/g, '\n');
+    return { blocks: parseBlocks(text.split('\n'), 0) };
+}
+function isBlank(line) {
+    return line.trim() === '';
+}
+function listMarker(line) {
+    const bullet = BULLET.exec(line);
+    if (bullet)
+        return { ordered: false, start: 1, content: bullet[3] ?? '' };
+    const ordered = ORDERED.exec(line);
+    if (ordered)
+        return { ordered: true, start: Number(ordered[2]), content: ordered[3] ?? '' };
+    return null;
+}
+/** True when `line` starts a block other than a paragraph continuation. */
+function startsBlock(line) {
+    return (FENCE.test(line) ||
+        HEADING.test(line) ||
+        RULE.test(line) ||
+        QUOTE.test(line) ||
+        listMarker(line) !== null);
+}
+function parseBlocks(lines, depth) {
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? '';
+        if (isBlank(line)) {
+            i += 1;
+            continue;
+        }
+        const fence = FENCE.exec(line);
+        if (fence) {
+            const marker = fence[1] ?? '```';
+            const body = [];
+            i += 1;
+            while (i < lines.length && !(lines[i] ?? '').trim().startsWith(marker)) {
+                body.push(lines[i] ?? '');
+                i += 1;
+            }
+            i += 1; // closing fence (or end of input)
+            blocks.push({ type: 'code', lang: fence[2]?.toLowerCase(), text: body.join('\n') });
+            continue;
+        }
+        const heading = HEADING.exec(line);
+        if (heading) {
+            const level = (heading[1] ?? '#').length;
+            blocks.push({ type: 'heading', level, children: parseInline(heading[2] ?? '', 0) });
+            i += 1;
+            continue;
+        }
+        if (RULE.test(line)) {
+            blocks.push({ type: 'rule' });
+            i += 1;
+            continue;
+        }
+        if (QUOTE.test(line)) {
+            const inner = [];
+            while (i < lines.length && QUOTE.test(lines[i] ?? '')) {
+                inner.push(QUOTE.exec(lines[i] ?? '')?.[1] ?? '');
+                i += 1;
+            }
+            blocks.push(depth < MARKDOWN_LIMITS.blockDepth
+                ? { type: 'quote', children: parseBlocks(inner, depth + 1) }
+                : { type: 'paragraph', children: parseInline(inner.join('\n'), 0) });
+            continue;
+        }
+        const marker = listMarker(line);
+        if (marker) {
+            const parsed = parseList(lines, i, marker.ordered, marker.start, depth);
+            blocks.push(parsed.block);
+            i = parsed.next;
+            continue;
+        }
+        const paragraph = [line];
+        i += 1;
+        while (i < lines.length && !isBlank(lines[i] ?? '') && !startsBlock(lines[i] ?? '')) {
+            paragraph.push(lines[i] ?? '');
+            i += 1;
+        }
+        blocks.push({ type: 'paragraph', children: parseInline(paragraph.join('\n'), 0) });
+    }
+    return blocks;
+}
+function parseList(lines, from, ordered, start, depth) {
+    const items = [];
+    let i = from;
+    while (i < lines.length) {
+        const marker = listMarker(lines[i] ?? '');
+        if (!marker || marker.ordered !== ordered)
+            break;
+        const body = [marker.content];
+        i += 1;
+        // Continuation: indented lines (nested lists, wrapped text) and lazy
+        // paragraph lines that do not start another block.
+        while (i < lines.length) {
+            const next = lines[i] ?? '';
+            if (isBlank(next)) {
+                const after = lines[i + 1] ?? '';
+                if (/^ {2,}\S/.test(after)) {
+                    body.push('');
+                    i += 1;
+                    continue;
+                }
+                break;
+            }
+            if (/^ {2,}\S/.test(next)) {
+                body.push(next.replace(/^ {2,4}/, ''));
+                i += 1;
+                continue;
+            }
+            if (startsBlock(next))
+                break;
+            body.push(next);
+            i += 1;
+        }
+        let checked = null;
+        const task = TASK.exec(body[0] ?? '');
+        if (task) {
+            checked = task[1] !== ' ';
+            body[0] = (body[0] ?? '').slice(task[0].length);
+        }
+        const children = depth < MARKDOWN_LIMITS.blockDepth
+            ? parseBlocks(body, depth + 1)
+            : [{ type: 'paragraph', children: parseInline(body.join('\n'), 0) }];
+        items.push({ checked, children });
+    }
+    return { block: { type: 'list', ordered, start, items }, next: i };
+}
+const ESCAPABLE = /[\\`*_{}[\]()#+\-.!~<>|]/;
+/** Parses inline Markdown; `depth` caps nested emphasis and links. */
+export function parseInline(source, depth, inLink = false) {
+    const out = [];
+    let buffer = '';
+    const flush = () => {
+        if (buffer)
+            out.push({ type: 'text', text: buffer });
+        buffer = '';
+    };
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i] ?? '';
+        if (ch === '\\') {
+            const next = source[i + 1] ?? '';
+            if (next === '\n') {
+                flush();
+                out.push({ type: 'break' });
+                i += 2;
+                continue;
+            }
+            if (ESCAPABLE.test(next)) {
+                buffer += next;
+                i += 2;
+                continue;
+            }
+        }
+        if (ch === '\n') {
+            if (/ {2,}$/.test(buffer)) {
+                buffer = buffer.replace(/ +$/, '');
+                flush();
+                out.push({ type: 'break' });
+            }
+            else {
+                buffer += '\n';
+            }
+            i += 1;
+            continue;
+        }
+        if (ch === '`') {
+            const run = /^`+/.exec(source.slice(i))?.[0] ?? '`';
+            const close = source.indexOf(run, i + run.length);
+            if (close !== -1) {
+                flush();
+                const code = source.slice(i + run.length, close).replace(/\n/g, ' ');
+                out.push({
+                    type: 'code',
+                    text: code.length > 2 && /^ .* $/.test(code) ? code.slice(1, -1) : code,
+                });
+                i = close + run.length;
+                continue;
+            }
+            buffer += run;
+            i += run.length;
+            continue;
+        }
+        if (depth < MARKDOWN_LIMITS.inlineDepth) {
+            const emphasis = matchEmphasis(source, i);
+            if (emphasis) {
+                flush();
+                out.push({
+                    type: emphasis.type,
+                    children: parseInline(source.slice(emphasis.innerStart, emphasis.innerEnd), depth + 1, inLink),
+                });
+                i = emphasis.end;
+                continue;
+            }
+            if (ch === '!' && source[i + 1] === '[') {
+                const image = matchLink(source, i + 1);
+                if (image) {
+                    // Images are not loaded from text blocks: keep the alt text only.
+                    buffer += source.slice(image.labelStart, image.labelEnd);
+                    i = image.end;
+                    continue;
+                }
+            }
+            if (ch === '[' && !inLink) {
+                const link = matchLink(source, i);
+                if (link) {
+                    flush();
+                    out.push({
+                        type: 'link',
+                        href: safeHref(link.href),
+                        children: parseInline(source.slice(link.labelStart, link.labelEnd), depth + 1, true),
+                    });
+                    i = link.end;
+                    continue;
+                }
+            }
+            if (ch === '<' && !inLink) {
+                const auto = /^<((?:https?:\/\/|mailto:)[^\s<>]+)>/i.exec(source.slice(i));
+                if (auto?.[1]) {
+                    flush();
+                    out.push({
+                        type: 'link',
+                        href: safeHref(auto[1]),
+                        children: [{ type: 'text', text: auto[1] }],
+                    });
+                    i += auto[0].length;
+                    continue;
+                }
+            }
+        }
+        buffer += ch;
+        i += 1;
+    }
+    flush();
+    return out;
+}
+function matchEmphasis(source, at) {
+    const candidates = [
+        { marker: '**', type: 'strong' },
+        { marker: '__', type: 'strong' },
+        { marker: '~~', type: 'del' },
+        { marker: '*', type: 'em' },
+        { marker: '_', type: 'em' },
+    ];
+    for (const { marker, type } of candidates) {
+        if (!source.startsWith(marker, at))
+            continue;
+        const innerStart = at + marker.length;
+        const first = source[innerStart] ?? '';
+        if (first === '' || /\s/.test(first))
+            continue;
+        // `_` inside a word (snake_case) is literal.
+        if (marker[0] === '_' && /[\p{L}\p{N}]/u.test(source[at - 1] ?? ''))
+            continue;
+        let close = source.indexOf(marker, innerStart + 1);
+        while (close !== -1) {
+            const before = source[close - 1] ?? '';
+            const after = source[close + marker.length] ?? '';
+            const doubled = marker.length === 1 && after === marker;
+            const midWord = marker[0] === '_' && /[\p{L}\p{N}]/u.test(after);
+            if (!/\s/.test(before) && before !== '\\' && !doubled && !midWord)
+                break;
+            close = source.indexOf(marker, close + (doubled ? 2 : 1));
+        }
+        if (close === -1)
+            continue;
+        return { type, innerStart, innerEnd: close, end: close + marker.length };
+    }
+    return null;
+}
+function matchLink(source, at) {
+    let level = 0;
+    let labelEnd = -1;
+    for (let j = at; j < source.length; j += 1) {
+        const c = source[j];
+        if (c === '\\') {
+            j += 1;
+            continue;
+        }
+        if (c === '[')
+            level += 1;
+        else if (c === ']') {
+            level -= 1;
+            if (level === 0) {
+                labelEnd = j;
+                break;
+            }
+        }
+        else if (c === '\n' && source[j + 1] === '\n')
+            return null;
+    }
+    if (labelEnd === -1 || source[labelEnd + 1] !== '(')
+        return null;
+    const target = /^\(\s*<?((?:[^\s()<>]|\([^\s()<>]*\))*)>?(?:\s+"[^"\n]*")?\s*\)/.exec(source.slice(labelEnd + 1));
+    if (!target)
+        return null;
+    return {
+        labelStart: at + 1,
+        labelEnd,
+        href: target[1] ?? '',
+        end: labelEnd + 1 + target[0].length,
+    };
+}
+/** Plain text of an inline tree (for accessible names and summaries). */
+export function inlineText(nodes) {
+    let text = '';
+    for (const node of nodes) {
+        if (node.type === 'text' || node.type === 'code')
+            text += node.text;
+        else if (node.type === 'break')
+            text += '\n';
+        else
+            text += inlineText(node.children);
+    }
+    return text;
+}
+/**
+ * Distinct heading levels used anywhere in the tree, ascending. Renderers map
+ * them onto consecutive outline levels (`##` then `####` become h3 then h4).
+ */
+export function headingLevels(blocks) {
+    const found = new Set();
+    const visit = (items) => {
+        for (const block of items) {
+            if (block.type === 'heading')
+                found.add(block.level);
+            else if (block.type === 'quote')
+                visit(block.children);
+            else if (block.type === 'list')
+                for (const item of block.items)
+                    visit(item.children);
+        }
+    };
+    visit(blocks);
+    return [...found].sort((a, b) => a - b);
+}

package/dist/text/renderers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Eager entry for hosts that render text blocks on first paint. Most hosts
+ * should prefer `loadTextFamily()` from `@texuli/blocks` (lazy chunk).
+ */
+export { default as RichText } from './RichText.svelte';
+export { default as TextBlockView } from './TextBlockView.svelte';

package/dist/text/renderers.js

@@ -0,0 +1,6 @@
+/**
+ * Eager entry for hosts that render text blocks on first paint. Most hosts
+ * should prefer `loadTextFamily()` from `@texuli/blocks` (lazy chunk).
+ */
+export { default as RichText } from './RichText.svelte';
+export { default as TextBlockView } from './TextBlockView.svelte';

package/package.json

@@ -1,6 +1,169 @@
 {
   "name": "@texuli/blocks",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-next.0",
+  "description": "Content blocks: closed vocabulary, untrusted guard, formula AST and catalog metadata for pages, documents and slides.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./code": {
+      "types": "./dist/code/index.d.ts",
+      "default": "./dist/code/index.js"
+    },
+    "./code/engine": {
+      "types": "./dist/code/engine-entry.d.ts",
+      "default": "./dist/code/engine-entry.js"
+    },
+    "./code/renderers": {
+      "types": "./dist/code/renderers.d.ts",
+      "svelte": "./dist/code/renderers.js",
+      "default": "./dist/code/renderers.js"
+    },
+    "./code/tokenizer": {
+      "types": "./dist/code/engine.d.ts",
+      "default": "./dist/code/engine.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    },
+    "./data": {
+      "types": "./dist/data/index.d.ts",
+      "default": "./dist/data/index.js"
+    },
+    "./data/engine": {
+      "types": "./dist/data/engine.d.ts",
+      "default": "./dist/data/engine.js"
+    },
+    "./data/renderers": {
+      "types": "./dist/data/renderers.d.ts",
+      "svelte": "./dist/data/renderers.js",
+      "default": "./dist/data/renderers.js"
+    },
+    "./diagram": {
+      "types": "./dist/diagram/index.d.ts",
+      "default": "./dist/diagram/index.js"
+    },
+    "./diagram/engine": {
+      "types": "./dist/diagram/engine.d.ts",
+      "default": "./dist/diagram/engine.js"
+    },
+    "./diagram/renderers": {
+      "types": "./dist/diagram/DiagramFamily.svelte.d.ts",
+      "svelte": "./dist/diagram/DiagramFamily.svelte",
+      "default": "./dist/diagram/DiagramFamily.svelte"
+    },
+    "./embed": {
+      "types": "./dist/embed/index.d.ts",
+      "svelte": "./dist/embed/index.js",
+      "default": "./dist/embed/index.js"
+    },
+    "./embed/engine": {
+      "types": "./dist/embed/engine.d.ts",
+      "default": "./dist/embed/engine.js"
+    },
+    "./embed/renderers": {
+      "types": "./dist/embed/renderers.d.ts",
+      "svelte": "./dist/embed/renderers.js",
+      "default": "./dist/embed/renderers.js"
+    },
+    "./formula": {
+      "types": "./dist/core/formula/index.d.ts",
+      "default": "./dist/core/formula/index.js"
+    },
+    "./interactive": {
+      "types": "./dist/interactive/index.d.ts",
+      "default": "./dist/interactive/index.js"
+    },
+    "./interactive/engine": {
+      "types": "./dist/interactive/engine.d.ts",
+      "default": "./dist/interactive/engine.js"
+    },
+    "./interactive/renderers": {
+      "types": "./dist/interactive/renderers.d.ts",
+      "svelte": "./dist/interactive/renderers.js",
+      "default": "./dist/interactive/renderers.js"
+    },
+    "./map": {
+      "types": "./dist/map/index.d.ts",
+      "default": "./dist/map/index.js"
+    },
+    "./map/engine": {
+      "types": "./dist/map/engine.d.ts",
+      "default": "./dist/map/engine.js"
+    },
+    "./map/renderers": {
+      "types": "./dist/map/renderers.d.ts",
+      "svelte": "./dist/map/renderers.js",
+      "default": "./dist/map/renderers.js"
+    },
+    "./media": {
+      "types": "./dist/media/index.d.ts",
+      "default": "./dist/media/index.js"
+    },
+    "./media/engine": {
+      "types": "./dist/media/engine.d.ts",
+      "default": "./dist/media/engine.js"
+    },
+    "./media/renderers": {
+      "types": "./dist/media/renderers.d.ts",
+      "svelte": "./dist/media/renderers.js",
+      "default": "./dist/media/renderers.js"
+    },
+    "./structure": {
+      "types": "./dist/structure/index.d.ts",
+      "default": "./dist/structure/index.js"
+    },
+    "./structure/engine": {
+      "types": "./dist/structure/engine.d.ts",
+      "default": "./dist/structure/engine.js"
+    },
+    "./structure/renderers": {
+      "types": "./dist/structure/renderers.d.ts",
+      "svelte": "./dist/structure/renderers.js",
+      "default": "./dist/structure/renderers.js"
+    },
+    "./text": {
+      "types": "./dist/text/index.d.ts",
+      "default": "./dist/text/index.js"
+    },
+    "./text/engine": {
+      "types": "./dist/text/engine.d.ts",
+      "default": "./dist/text/engine.js"
+    },
+    "./text/markdown": {
+      "types": "./dist/text/markdown.d.ts",
+      "default": "./dist/text/markdown.js"
+    },
+    "./text/renderers": {
+      "types": "./dist/text/renderers.d.ts",
+      "svelte": "./dist/text/renderers.js",
+      "default": "./dist/text/renderers.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@texuli/core": "0.1.0-next.0",
+    "@texuli/tokens": "0.1.0-next.0",
+    "texuli": "0.1.0-next.0",
+    "@texuli/charts": "0.1.0-next.0",
+    "@texuli/data": "0.1.0-next.0",
+    "@texuli/media": "0.1.0-next.0"
+  },
+  "peerDependencies": {
+    "svelte": "^5.57.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  }
+}