@avocadostudio-ai/richtext 0.7.0 → 0.8.0

package/dist/doc.d.ts

@@ -57,6 +57,17 @@ export declare const NODE: {
      * survives a trip through the property panel in its original position.
      */
     readonly unknown: "avocadoUnknownBlock";
+    /**
+     * The same thing in inline position: a `<br class="hidden md:inline">`, an
+     * `<img>` or any other void element sitting inside a run of text.
+     *
+     * It is a separate name from `avocadoUnknownBlock` because ProseMirror makes
+     * a node inline or block and never both, and a paragraph's content is
+     * `inline*`. Emitting the block name here put a block node inside a
+     * paragraph, which is not a document the editor's schema can hold: it was
+     * dropped on load, taking the element with it.
+     */
+    readonly unknownInline: "avocadoUnknownInline";
 };
 /** Mark names this package produces and understands. */
 export declare const MARK: {
@@ -66,6 +77,21 @@ export declare const MARK: {
     readonly code: "code";
     readonly underline: "underline";
     readonly link: "link";
+    /**
+     * An inline element the pivot has no mark for, carried rather than dropped.
+     *
+     * The inline twin of `avocadoUnknownBlock`, and it exists for HTML: a
+     * template stores `<span class="hidden xl:inline">creating websites with</span>`
+     * as content, and neither half of that can be thrown away. The text inside
+     * is ordinary editable text; the wrapper rides along in `attrs` as its tag
+     * and its attributes in source order, and is re-emitted around whatever the
+     * text became.
+     *
+     * Unknown marks already survive a round trip untouched — the Storyblok
+     * converter relies on it for `styled` and `highlight`. This one is named so
+     * the HTML converter can recognise its own and rebuild the element.
+     */
+    readonly unknownHtml: "avocadoUnknownHtml";
 };
 /**
  * A richtext value stored as a document rather than a markdown string.

package/dist/doc.js

@@ -42,7 +42,18 @@ export const NODE = {
      * unchanged. The editor registers a matching read-only node, so it also
      * survives a trip through the property panel in its original position.
      */
-    unknown: "avocadoUnknownBlock"
+    unknown: "avocadoUnknownBlock",
+    /**
+     * The same thing in inline position: a `<br class="hidden md:inline">`, an
+     * `<img>` or any other void element sitting inside a run of text.
+     *
+     * It is a separate name from `avocadoUnknownBlock` because ProseMirror makes
+     * a node inline or block and never both, and a paragraph's content is
+     * `inline*`. Emitting the block name here put a block node inside a
+     * paragraph, which is not a document the editor's schema can hold: it was
+     * dropped on load, taking the element with it.
+     */
+    unknownInline: "avocadoUnknownInline"
 };
 /** Mark names this package produces and understands. */
 export const MARK = {
@@ -51,7 +62,22 @@ export const MARK = {
     strike: "strike",
     code: "code",
     underline: "underline",
-    link: "link"
+    link: "link",
+    /**
+     * An inline element the pivot has no mark for, carried rather than dropped.
+     *
+     * The inline twin of `avocadoUnknownBlock`, and it exists for HTML: a
+     * template stores `<span class="hidden xl:inline">creating websites with</span>`
+     * as content, and neither half of that can be thrown away. The text inside
+     * is ordinary editable text; the wrapper rides along in `attrs` as its tag
+     * and its attributes in source order, and is re-emitted around whatever the
+     * text became.
+     *
+     * Unknown marks already survive a round trip untouched — the Storyblok
+     * converter relies on it for `styled` and `highlight`. This one is named so
+     * the HTML converter can recognise its own and rebuild the element.
+     */
+    unknownHtml: "avocadoUnknownHtml"
 };
 /**
  * A richtext value stored as a document rather than a markdown string.

package/dist/html.d.ts

@@ -0,0 +1,72 @@
+/**
+ * HTML <-> the pivot document.
+ *
+ * The other converters in this package each serve one CMS. This one serves a
+ * shape no CMS produces and most templates do: a prop that is a string of HTML,
+ * rendered with Astro's `set:html`, React's `dangerouslySetInnerHTML` or Vue's
+ * `v-html`. A site that renders its own components stores those strings as
+ * content, because from the template's point of view that is what they are.
+ *
+ * Before this existed the only declarable kind close enough was `richtext`, and
+ * it is the wrong one: `richtext` means *a document*, and what arrives is a
+ * string. The panel therefore rendered the markup literally —
+ *
+ *     Free template for <span class="hidden xl:inline">creating websites with</span> …
+ *
+ * — which a person cannot edit without breaking, and which is written back to
+ * the site's own source file if they edit it anyway.
+ *
+ * ## What survives
+ *
+ * Tags with a pivot equivalent become nodes and marks. Everything else is
+ * **preserved, not dropped**, which is the decision this file turns on. A
+ * converter that discarded an unrecognised tag would corrupt the source on the
+ * first save of a neighbouring field — the failure mode is silent, and the
+ * content is gone by the time anyone reads the page. So:
+ *
+ *   - An unknown element wrapping text (`<span class="hidden xl:inline">…`)
+ *     becomes a mark named `MARK.unknownHtml`, carrying its tag and its
+ *     attributes in source order. The text inside stays editable; the wrapper
+ *     rides along and is re-emitted around whatever the text became.
+ *   - An unknown element with no children (`<div class="absolute inset-0 …">`,
+ *     an `<img>`) becomes `avocadoUnknownBlock` holding its source markup. The
+ *     panel shows it read-only, and `toHtml` re-emits it byte for byte.
+ *
+ * ## Round trip
+ *
+ * `toHtml(fromHtml(s))` is the contract, and it is *semantic* equality, not
+ * byte equality. It **is** idempotent from the first pass —
+ * `toHtml(fromHtml(toHtml(fromHtml(s))))` equals `toHtml(fromHtml(s))` — which
+ * is the property that actually matters, because that is what decides whether
+ * opening a page in the editor and saving it produces a diff for ever after.
+ *
+ * Measured against the pilot page's nineteen markup-bearing values, sixteen
+ * come back byte-identical and three are normalised once:
+ *
+ *   - attribute quoting becomes double quotes, and a boolean attribute becomes
+ *     `attr=""`;
+ *   - stray whitespace inside a tag is dropped — `</span >` and `class="x" >`
+ *     come back closed up;
+ *   - loose text sitting after a block element is wrapped in the paragraph it
+ *     already was — `<h3>Title</h3> Body` becomes `<h3>Title</h3><p> Body</p>`.
+ *
+ * All three are the parse writing down what the markup already meant. None of
+ * them loses a character of content, and none of them recurs.
+ *
+ * One deliberate asymmetry: an input with no block-level tag at all — which is
+ * every headline field we have seen — parses to a single paragraph and is
+ * emitted back **without** a `<p>` wrapper. Emitting one would mean that
+ * opening a page and saving it changed every title on it.
+ */
+import { type RichTextDoc } from "./doc.ts";
+export declare function decodeEntities(s: string): string;
+/**
+ * Text, escaped for a text node.
+ *
+ * ` ` goes back out as `&nbsp;` rather than as a literal byte: it is
+ * invisible in a diff otherwise, and a non-breaking space in a headline is
+ * usually load-bearing — it is what keeps "Astro + Tailwind" off two lines.
+ */
+export declare function escapeHtmlText(s: string): string;
+export declare function fromHtml(html: unknown): RichTextDoc;
+export declare function toHtml(doc: unknown): string;

package/dist/html.js

@@ -0,0 +1,471 @@
+/**
+ * HTML <-> the pivot document.
+ *
+ * The other converters in this package each serve one CMS. This one serves a
+ * shape no CMS produces and most templates do: a prop that is a string of HTML,
+ * rendered with Astro's `set:html`, React's `dangerouslySetInnerHTML` or Vue's
+ * `v-html`. A site that renders its own components stores those strings as
+ * content, because from the template's point of view that is what they are.
+ *
+ * Before this existed the only declarable kind close enough was `richtext`, and
+ * it is the wrong one: `richtext` means *a document*, and what arrives is a
+ * string. The panel therefore rendered the markup literally —
+ *
+ *     Free template for <span class="hidden xl:inline">creating websites with</span> …
+ *
+ * — which a person cannot edit without breaking, and which is written back to
+ * the site's own source file if they edit it anyway.
+ *
+ * ## What survives
+ *
+ * Tags with a pivot equivalent become nodes and marks. Everything else is
+ * **preserved, not dropped**, which is the decision this file turns on. A
+ * converter that discarded an unrecognised tag would corrupt the source on the
+ * first save of a neighbouring field — the failure mode is silent, and the
+ * content is gone by the time anyone reads the page. So:
+ *
+ *   - An unknown element wrapping text (`<span class="hidden xl:inline">…`)
+ *     becomes a mark named `MARK.unknownHtml`, carrying its tag and its
+ *     attributes in source order. The text inside stays editable; the wrapper
+ *     rides along and is re-emitted around whatever the text became.
+ *   - An unknown element with no children (`<div class="absolute inset-0 …">`,
+ *     an `<img>`) becomes `avocadoUnknownBlock` holding its source markup. The
+ *     panel shows it read-only, and `toHtml` re-emits it byte for byte.
+ *
+ * ## Round trip
+ *
+ * `toHtml(fromHtml(s))` is the contract, and it is *semantic* equality, not
+ * byte equality. It **is** idempotent from the first pass —
+ * `toHtml(fromHtml(toHtml(fromHtml(s))))` equals `toHtml(fromHtml(s))` — which
+ * is the property that actually matters, because that is what decides whether
+ * opening a page in the editor and saving it produces a diff for ever after.
+ *
+ * Measured against the pilot page's nineteen markup-bearing values, sixteen
+ * come back byte-identical and three are normalised once:
+ *
+ *   - attribute quoting becomes double quotes, and a boolean attribute becomes
+ *     `attr=""`;
+ *   - stray whitespace inside a tag is dropped — `</span >` and `class="x" >`
+ *     come back closed up;
+ *   - loose text sitting after a block element is wrapped in the paragraph it
+ *     already was — `<h3>Title</h3> Body` becomes `<h3>Title</h3><p> Body</p>`.
+ *
+ * All three are the parse writing down what the markup already meant. None of
+ * them loses a character of content, and none of them recurs.
+ *
+ * One deliberate asymmetry: an input with no block-level tag at all — which is
+ * every headline field we have seen — parses to a single paragraph and is
+ * emitted back **without** a `<p>` wrapper. Emitting one would mean that
+ * opening a page and saving it changed every title on it.
+ */
+import { NODE, MARK, emptyDoc } from "./doc.js";
+/** Block-level tags with a pivot node, and the node they become. */
+const BLOCK_TAGS = {
+    p: NODE.paragraph,
+    h1: NODE.heading, h2: NODE.heading, h3: NODE.heading,
+    h4: NODE.heading, h5: NODE.heading, h6: NODE.heading,
+    ul: NODE.bulletList,
+    ol: NODE.orderedList,
+    li: NODE.listItem,
+    blockquote: NODE.blockquote,
+    pre: NODE.codeBlock,
+    hr: NODE.horizontalRule
+};
+/** Inline tags with a pivot mark, and the mark they become. */
+const MARK_TAGS = {
+    strong: MARK.bold, b: MARK.bold,
+    em: MARK.italic, i: MARK.italic,
+    s: MARK.strike, del: MARK.strike, strike: MARK.strike,
+    code: MARK.code,
+    u: MARK.underline,
+    a: MARK.link
+};
+/** The tag each mark is written back as. The first spelling above wins. */
+const MARK_TAG_OUT = {
+    [MARK.bold]: "strong",
+    [MARK.italic]: "em",
+    [MARK.strike]: "s",
+    [MARK.code]: "code",
+    [MARK.underline]: "u",
+    [MARK.link]: "a"
+};
+/** Elements that never have children, whatever the source wrote. */
+const VOID_TAGS = new Set(["br", "hr", "img", "input", "meta", "link", "source", "wbr", "area", "col", "embed", "track"]);
+const ENTITIES = {
+    amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " "
+};
+export function decodeEntities(s) {
+    return s.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (whole, body) => {
+        if (body[0] === "#") {
+            const code = body[1] === "x" || body[1] === "X"
+                ? Number.parseInt(body.slice(2), 16)
+                : Number.parseInt(body.slice(1), 10);
+            return Number.isFinite(code) && code > 0 ? String.fromCodePoint(code) : whole;
+        }
+        return ENTITIES[body.toLowerCase()] ?? whole;
+    });
+}
+/**
+ * Text, escaped for a text node.
+ *
+ * ` ` goes back out as `&nbsp;` rather than as a literal byte: it is
+ * invisible in a diff otherwise, and a non-breaking space in a headline is
+ * usually load-bearing — it is what keeps "Astro + Tailwind" off two lines.
+ */
+export function escapeHtmlText(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/ /g, "&nbsp;");
+}
+function escapeAttr(s) {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/ /g, "&nbsp;");
+}
+const TAG_RE = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s/>"'=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*(\/?)>/g;
+const ATTR_RE = /([^\s/>"'=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+function tokenize(html) {
+    const tokens = [];
+    let last = 0;
+    TAG_RE.lastIndex = 0;
+    for (let m = TAG_RE.exec(html); m !== null; m = TAG_RE.exec(html)) {
+        if (m.index > last)
+            tokens.push({ kind: "text", text: html.slice(last, m.index) });
+        last = TAG_RE.lastIndex;
+        const tag = m[2].toLowerCase();
+        if (m[1] === "/") {
+            tokens.push({ kind: "close", tag });
+            continue;
+        }
+        const attrs = [];
+        ATTR_RE.lastIndex = 0;
+        for (let a = ATTR_RE.exec(m[3] ?? ""); a !== null; a = ATTR_RE.exec(m[3] ?? "")) {
+            attrs.push([a[1], decodeEntities(a[2] ?? a[3] ?? a[4] ?? "")]);
+        }
+        tokens.push({ kind: "open", tag, attrs, selfClosing: m[4] === "/" || VOID_TAGS.has(tag) });
+    }
+    if (last < html.length)
+        tokens.push({ kind: "text", text: html.slice(last) });
+    return tokens;
+}
+/**
+ * Attributes carried on a node or mark, rendered back.
+ *
+ * A tag the pivot *does* model can still have attributes it does not —
+ * `<h3 class="text-2xl font-bold …">` is a heading and the class is the whole
+ * of its appearance. Modelling the tag and dropping the class is the worst of
+ * the three outcomes: it looks like a faithful conversion and silently
+ * restyles the page.
+ */
+function renderAttrs(value) {
+    if (!Array.isArray(value))
+        return "";
+    return value
+        .map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`)
+        .join("");
+}
+/** An element's source markup, for the unknown-block slot. */
+function serializeUnknown(tag, attrs, selfClosing) {
+    const rendered = attrs.map(([k, v]) => ` ${k}="${escapeAttr(v)}"`).join("");
+    return selfClosing && VOID_TAGS.has(tag) ? `<${tag}${rendered} />` : `<${tag}${rendered}></${tag}>`;
+}
+export function fromHtml(html) {
+    if (typeof html !== "string" || html.trim().length === 0)
+        return emptyDoc();
+    const doc = emptyDoc();
+    /** Block nodes being filled, outermost first. `undefined` = top level. */
+    const blocks = [];
+    /** Inline marks currently open, innermost last. */
+    const marks = [];
+    const open = [];
+    const currentContainer = () => {
+        for (let i = blocks.length - 1; i >= 0; i--) {
+            const node = blocks[i];
+            if (!node.content)
+                node.content = [];
+            return node.content;
+        }
+        return doc.content;
+    };
+    /** Nodes that hold inline content directly; everything else needs a paragraph. */
+    const INLINE_CONTAINERS = new Set([NODE.paragraph, NODE.heading, NODE.codeBlock]);
+    /*
+     * The paragraph loose inline content is currently accumulating in, or null
+     * when nothing is open.
+     *
+     * It is the difference between "still in the same run of text" and "the
+     * previous sibling happened to be a paragraph", which matters when an
+     * element arrives that could go either way. Cleared whenever a block opens
+     * or closes, because either ends the run.
+     */
+    let looseParagraph = null;
+    /** The paragraph loose inline content belongs in, created on demand. */
+    const inlineTarget = () => {
+        const container = currentContainer();
+        const innermost = blocks[blocks.length - 1];
+        if (innermost && INLINE_CONTAINERS.has(innermost.type))
+            return container;
+        const tail = container[container.length - 1];
+        if (looseParagraph && tail === looseParagraph) {
+            if (!tail.content)
+                tail.content = [];
+            return tail.content;
+        }
+        const paragraph = { type: NODE.paragraph, content: [] };
+        container.push(paragraph);
+        looseParagraph = paragraph;
+        return paragraph.content;
+    };
+    /**
+     * An element the grammar has no node for, placed by where it was found.
+     *
+     * In inline position — inside a paragraph or a heading, or mid-run of loose
+     * text — it is an inline node, so it keeps its place among the words. At
+     * block level it is a block, a sibling of the paragraphs around it.
+     *
+     * Getting this wrong is not cosmetic. Appending a block-level `<div>` to the
+     * paragraph before it emits `<p>before<div></div></p>`, which is markup no
+     * browser keeps: the parser closes the `<p>` at the `<div>` and the page
+     * gains an empty paragraph on the first save of an unrelated field.
+     */
+    const pushUnknownElement = (html) => {
+        const innermost = blocks[blocks.length - 1];
+        const inlinePosition = (innermost && INLINE_CONTAINERS.has(innermost.type)) || looseParagraph !== null;
+        if (inlinePosition) {
+            inlineTarget().push({ type: NODE.unknownInline, attrs: { data: { html } } });
+            return;
+        }
+        currentContainer().push({ type: NODE.unknown, attrs: { data: { html } } });
+    };
+    let textCount = 0;
+    const pushText = (text) => {
+        if (text.length === 0)
+            return;
+        const node = { type: NODE.text, text };
+        if (marks.length > 0)
+            node.marks = marks.map((m) => ({ ...m }));
+        inlineTarget().push(node);
+        textCount++;
+    };
+    for (const token of tokenize(html)) {
+        if (token.kind === "text") {
+            pushText(decodeEntities(token.text));
+            continue;
+        }
+        if (token.kind === "close") {
+            for (let i = open.length - 1; i >= 0; i--) {
+                if (open[i].tag !== token.tag)
+                    continue;
+                const frame = open.splice(i, 1)[0];
+                if (frame.mark) {
+                    const at = marks.lastIndexOf(frame.mark);
+                    if (at >= 0)
+                        marks.splice(at, 1);
+                    if (frame.unknownHtml !== undefined && textCount === frame.textCountAtOpen) {
+                        pushUnknownElement(frame.unknownHtml);
+                    }
+                }
+                else {
+                    const at = blocks.lastIndexOf(frame.node);
+                    if (at >= 0)
+                        blocks.splice(at, 1);
+                    looseParagraph = null;
+                }
+                break;
+            }
+            continue;
+        }
+        const { tag, attrs, selfClosing } = token;
+        if (tag === "br") {
+            /*
+             * Only a bare `<br>` is a hard break. `<br class="hidden md:inline" />`
+             * is a responsive layout decision, and a hard break has nowhere to keep
+             * the class — so it rides through whole instead. Dropping it would have
+             * changed where the line breaks on mobile, on the first save of an
+             * unrelated field, with nothing in the diff to explain it.
+             */
+            if (attrs.length === 0) {
+                inlineTarget().push({ type: NODE.hardBreak });
+            }
+            else {
+                pushUnknownElement(serializeUnknown(tag, attrs, true));
+            }
+            continue;
+        }
+        const blockType = BLOCK_TAGS[tag];
+        if (blockType !== undefined) {
+            const node = { type: blockType };
+            if (blockType === NODE.heading)
+                node.attrs = { level: Number(tag[1]) };
+            if (attrs.length > 0)
+                node.attrs = { ...(node.attrs ?? {}), htmlAttributes: attrs };
+            if (blockType !== NODE.horizontalRule)
+                node.content = [];
+            currentContainer().push(node);
+            looseParagraph = null;
+            if (blockType !== NODE.horizontalRule) {
+                blocks.push(node);
+                open.push({ tag, node });
+            }
+            continue;
+        }
+        const markType = MARK_TAGS[tag];
+        if (markType !== undefined && !selfClosing) {
+            const mark = { type: markType };
+            if (markType === MARK.link) {
+                const attrsOut = {};
+                for (const [k, v] of attrs)
+                    attrsOut[k] = v;
+                mark.attrs = attrsOut;
+            }
+            else if (attrs.length > 0) {
+                mark.attrs = { htmlAttributes: attrs };
+            }
+            marks.push(mark);
+            open.push({ tag, node: { type: NODE.text }, mark });
+            continue;
+        }
+        /*
+         * Unknown. With children it is a mark, so the text inside stays editable;
+         * with none there is no text to hang a mark on, so it rides as a block
+         * carrying its own markup.
+         */
+        if (selfClosing) {
+            pushUnknownElement(serializeUnknown(tag, attrs, true));
+            continue;
+        }
+        const mark = {
+            type: MARK.unknownHtml,
+            attrs: { tag, attributes: attrs.map(([k, v]) => [k, v]) }
+        };
+        marks.push(mark);
+        open.push({
+            tag,
+            node: { type: NODE.text },
+            mark,
+            unknownHtml: serializeUnknown(tag, attrs, false),
+            textCountAtOpen: textCount
+        });
+    }
+    return doc;
+}
+// ---------------------------------------------------------------------------
+// document -> html
+// ---------------------------------------------------------------------------
+function openTagFor(mark) {
+    if (mark.type === MARK.unknownHtml) {
+        const tag = String(mark.attrs?.tag ?? "span");
+        const pairs = Array.isArray(mark.attrs?.attributes) ? mark.attrs.attributes : [];
+        return `<${tag}${pairs.map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("")}>`;
+    }
+    const tag = MARK_TAG_OUT[mark.type];
+    if (!tag)
+        return "";
+    if (mark.type === MARK.link) {
+        const attrs = (mark.attrs ?? {});
+        const rendered = Object.entries(attrs)
+            .filter(([, v]) => v !== null && v !== undefined)
+            .map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`)
+            .join("");
+        return `<a${rendered}>`;
+    }
+    return `<${tag}${renderAttrs(mark.attrs?.htmlAttributes)}>`;
+}
+function closeTagFor(mark) {
+    const tag = mark.type === MARK.unknownHtml
+        ? String(mark.attrs?.tag ?? "span")
+        : MARK_TAG_OUT[mark.type];
+    return tag ? `</${tag}>` : "";
+}
+function markKey(mark) {
+    return mark.type === MARK.unknownHtml
+        ? `${mark.type}:${openTagFor(mark)}`
+        : `${mark.type}:${JSON.stringify(mark.attrs ?? null)}`;
+}
+/** Inline content, reopening a mark only where it actually changes. */
+function inlineToHtml(nodes) {
+    let out = "";
+    let openMarks = [];
+    const closeDownTo = (depth) => {
+        for (let i = openMarks.length - 1; i >= depth; i--)
+            out += closeTagFor(openMarks[i]);
+        openMarks = openMarks.slice(0, depth);
+    };
+    for (const node of nodes) {
+        if (node.type === NODE.hardBreak) {
+            closeDownTo(0);
+            out += "<br />";
+            continue;
+        }
+        if (node.type === NODE.unknownInline || node.type === NODE.unknown) {
+            closeDownTo(0);
+            const data = node.attrs?.data;
+            if (typeof data?.html === "string")
+                out += data.html;
+            continue;
+        }
+        if (node.type !== NODE.text || typeof node.text !== "string")
+            continue;
+        const wanted = node.marks ?? [];
+        let shared = 0;
+        while (shared < wanted.length && shared < openMarks.length && markKey(wanted[shared]) === markKey(openMarks[shared])) {
+            shared++;
+        }
+        closeDownTo(shared);
+        for (let i = shared; i < wanted.length; i++) {
+            out += openTagFor(wanted[i]);
+            openMarks.push(wanted[i]);
+        }
+        out += escapeHtmlText(node.text);
+    }
+    closeDownTo(0);
+    return out;
+}
+function blockToHtml(node) {
+    const inner = node.content ? node.content : [];
+    const a = renderAttrs(node.attrs?.htmlAttributes);
+    switch (node.type) {
+        case NODE.paragraph:
+            return `<p${a}>${inlineToHtml(inner)}</p>`;
+        case NODE.heading: {
+            const level = Number(node.attrs?.level ?? 1);
+            const tag = `h${level >= 1 && level <= 6 ? level : 1}`;
+            return `<${tag}${a}>${inlineToHtml(inner)}</${tag}>`;
+        }
+        case NODE.bulletList:
+            return `<ul${a}>${inner.map(blockToHtml).join("")}</ul>`;
+        case NODE.orderedList:
+            return `<ol${a}>${inner.map(blockToHtml).join("")}</ol>`;
+        case NODE.listItem:
+            return `<li${a}>${inner.map((c) => (c.type === NODE.paragraph && !c.attrs?.htmlAttributes ? inlineToHtml(c.content ?? []) : blockToHtml(c))).join("")}</li>`;
+        case NODE.blockquote:
+            return `<blockquote${a}>${inner.map(blockToHtml).join("")}</blockquote>`;
+        case NODE.codeBlock:
+            return `<pre${a}>${inlineToHtml(inner)}</pre>`;
+        case NODE.horizontalRule:
+            return `<hr${a} />`;
+        case NODE.unknownInline:
+        case NODE.unknown: {
+            const data = node.attrs?.data;
+            return typeof data?.html === "string" ? data.html : "";
+        }
+        default:
+            return inlineToHtml(inner);
+    }
+}
+export function toHtml(doc) {
+    if (typeof doc !== "object" || doc === null)
+        return "";
+    const content = doc.content;
+    if (!Array.isArray(content) || content.length === 0)
+        return "";
+    /*
+     * A field that arrived as inline markup goes back as inline markup. Wrapping
+     * it in the `<p>` the parse implied would mean every headline on the page
+     * came back changed the first time anyone opened it.
+     */
+    if (content.length === 1 && content[0].type === NODE.paragraph && !content[0].attrs?.htmlAttributes) {
+        return inlineToHtml(content[0].content ?? []);
+    }
+    return content.map(blockToHtml).join("");
+}

package/dist/index.d.ts

@@ -18,6 +18,7 @@
 export { parseInline, parseRichText, parseRichTextBlocks, normalizeRichTextBody, resolveRichTextHeadingLevel, clampMarkdownHeadings, unescapeMarkdownText, type InlineToken, type RichTextBlock, type RichTextList, type RichTextListItem } from "./parse.ts";
 export { NODE, MARK, isRichTextDoc, emptyDoc, fromMarkdown, toMarkdown, escapeMarkdownText, type RichTextDoc, type RichTextNode, type RichTextMark } from "./doc.ts";
 export { deepEqual, omitDeep, mergeByIdentity, mergeRichTextDoc } from "./merge.ts";
+export { fromHtml, toHtml, decodeEntities, escapeHtmlText } from "./html.ts";
 export { fromPortableText, toPortableText, type PortableTextBlock, type PortableTextSpan, type PortableTextMarkDef, type ToPortableTextOptions } from "./portable-text.ts";
 export { fromContentful, toContentful, type ContentfulDocument, type ContentfulNode, type ContentfulMark } from "./contentful.ts";
 export { fromStrapiBlocks, toStrapiBlocks, type StrapiNode, type StrapiText } from "./strapi.ts";

package/dist/index.js

@@ -18,6 +18,7 @@
 export { parseInline, parseRichText, parseRichTextBlocks, normalizeRichTextBody, resolveRichTextHeadingLevel, clampMarkdownHeadings, unescapeMarkdownText } from "./parse.js";
 export { NODE, MARK, isRichTextDoc, emptyDoc, fromMarkdown, toMarkdown, escapeMarkdownText } from "./doc.js";
 export { deepEqual, omitDeep, mergeByIdentity, mergeRichTextDoc } from "./merge.js";
+export { fromHtml, toHtml, decodeEntities, escapeHtmlText } from "./html.js";
 export { fromPortableText, toPortableText } from "./portable-text.js";
 export { fromContentful, toContentful } from "./contentful.js";
 export { fromStrapiBlocks, toStrapiBlocks } from "./strapi.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avocadostudio-ai/richtext",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,11 +12,6 @@
     },
     "./package.json": "./package.json"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/avocadostudio-ai/avocado.git",
-    "directory": "packages/richtext"
-  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
@@ -41,7 +36,7 @@
   "license": "Apache-2.0",
   "homepage": "https://docs.avocadostudio.dev",
   "bugs": {
-    "url": "https://github.com/avocadostudio-ai/avocado/issues"
+    "url": "https://docs.avocadostudio.dev"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",