@texuli/core 0.4.0 → 0.6.0

package/dist/editor/model.d.ts

@@ -2,9 +2,11 @@
  * `@texuli/core/editor-model`: the rich text editor document model (ADR-003).
  * Types and caps, the closed vocabularies, constructors, normalization,
  * validation, the untrusted loader, selection helpers, grapheme and word
- * boundaries, and the nested inline interchange shape. Framework-free.
+ * boundaries, the nested inline interchange shape, and host inline
+ * extensions (mentions, references). Framework-free.
  */
 export { blockLength, blockText, createEditorIds, type EditorAncestor, type EditorIdSource, type EditorLocation, editorBlockCount, editorCharCount, editorLeaves, editorPlainText, emptyEditorDocument, isTextBlock, isVoidBlock, locateBlock, nextEditorId, normalizeDocument, paragraph, removeBlocks, replaceBlock, replaceItem, validateEditorDocument, } from './document.js';
+export { acceptsExtensionId, createInlineExtensions, EDITOR_EXTENSION_LIMITS, EDITOR_EXTENSION_SIGILS, type EditorExtensionSigil, type EditorInlineExtension, type EditorInlineExtensions, extensionHref, toInlineExtensions, } from './extensions.js';
 export { graphemeBoundaries, nextGrapheme, nextWord, previousGrapheme, previousWord, snapToGrapheme, } from './graphemes.js';
 export { cleanText, hasMark, inheritedMarks, inlineLength, inlineText, markKey, normalizeInline, sliceInline, sortMarks, textToInline, } from './inline.js';
 export { type EditorLoadOptions, type EditorLoadResult, loadEditorDocument } from './load.js';

package/dist/editor/model.js

@@ -2,9 +2,11 @@
  * `@texuli/core/editor-model`: the rich text editor document model (ADR-003).
  * Types and caps, the closed vocabularies, constructors, normalization,
  * validation, the untrusted loader, selection helpers, grapheme and word
- * boundaries, and the nested inline interchange shape. Framework-free.
+ * boundaries, the nested inline interchange shape, and host inline
+ * extensions (mentions, references). Framework-free.
  */
 export { blockLength, blockText, createEditorIds, editorBlockCount, editorCharCount, editorLeaves, editorPlainText, emptyEditorDocument, isTextBlock, isVoidBlock, locateBlock, nextEditorId, normalizeDocument, paragraph, removeBlocks, replaceBlock, replaceItem, validateEditorDocument, } from "./document.js";
+export { acceptsExtensionId, createInlineExtensions, EDITOR_EXTENSION_LIMITS, EDITOR_EXTENSION_SIGILS, extensionHref, toInlineExtensions, } from "./extensions.js";
 export { graphemeBoundaries, nextGrapheme, nextWord, previousGrapheme, previousWord, snapToGrapheme, } from "./graphemes.js";
 export { cleanText, hasMark, inheritedMarks, inlineLength, inlineText, markKey, normalizeInline, sliceInline, sortMarks, textToInline, } from "./inline.js";
 export { loadEditorDocument } from "./load.js";

package/dist/editor/transforms.d.ts

@@ -50,7 +50,7 @@ export declare function toggleQuote(state: EditorState, options?: EditorTransfor
  * it). At a caret it toggles the stored marks for the next typed text. Code
  * text takes only `link` besides `code`.
  */
-export declare function toggleMark(state: EditorState, type: Exclude<EditorMarkType, 'link'>, options?: EditorTransformOptions): EditorTransformResult;
+export declare function toggleMark(state: EditorState, type: Exclude<EditorMarkType, 'link' | 'extension'>, options?: EditorTransformOptions): EditorTransformResult;
 export interface SetLinkOptions extends EditorTransformOptions {
     /** URL policy tier. Default `untrusted`; pasted and typed URLs stay untrusted. */
     trust?: HrefTrust;

package/dist/editor/tree.d.ts

@@ -20,8 +20,18 @@ export type EditorInlineNode = {
     type: 'link';
     href: string;
     children: EditorInlineNode[];
+}
+/** A host inline extension entity (`name`, `id`) around its label. */
+ | {
+    type: 'extension';
+    name: string;
+    id: string;
+    children: EditorInlineNode[];
 };
-/** Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`, `strike`). */
+/**
+ * Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`,
+ * `strike`, then `extension` innermost around its label).
+ */
 export declare function inlineToTree(content: readonly EditorInline[]): EditorInlineNode[];
 /**
  * Flatten a nested inline tree (this shape, the catalog's or the blocks

package/dist/editor/tree.js

@@ -1,6 +1,9 @@
 import { markKey, normalizeInline, sortMarks } from "./inline.js";
 import { LoadBudget } from "./load.js";
-/** Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`, `strike`). */
+/**
+ * Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`,
+ * `strike`, then `extension` innermost around its label).
+ */
 export function inlineToTree(content) {
     const root = [];
     const stack = [];
@@ -22,7 +25,9 @@ export function inlineToTree(content) {
         for (const mark of wanted.slice(common)) {
             const node = mark.type === 'link'
                 ? { type: 'link', href: mark.href, children: [] }
-                : { type: mark.type, children: [] };
+                : mark.type === 'extension'
+                    ? { type: 'extension', name: mark.name, id: mark.id, children: [] }
+                    : { type: mark.type, children: [] };
             children().push(node);
             stack.push({ mark, node });
         }
@@ -90,6 +95,10 @@ export function inlineFromTree(nodes, options = {}) {
                 const href = budget.href(node.href);
                 visit(node.children, href ? sortMarks([...marks, { type: 'link', href }]) : marks, depth + 1);
             }
+            else if (type === 'extension') {
+                const extension = budget.extension(node.name, node.id);
+                visit(node.children, extension ? sortMarks([...marks, extension]) : marks, depth + 1);
+            }
             else {
                 budget.report('unknown-node', 'Unknown inline nodes kept only their text.');
                 if (text !== undefined)

package/dist/editor/types.d.ts

@@ -18,6 +18,16 @@ export type EditorMark = {
 } | {
     type: 'link';
     href: string;
+}
+/**
+ * A host inline extension entity (a mention, a reference) over its label
+ * text: `name` is a registered extension, `id` the entity (G48). Excludes
+ * `link` and `code` on the same run.
+ */
+ | {
+    type: 'extension';
+    name: string;
+    id: string;
 };
 export type EditorMarkType = EditorMark['type'];
 export type EditorInline = {

package/dist/editor/types.js

@@ -27,6 +27,7 @@ export const EDITOR_MARK_ORDER = [
     'em',
     'strike',
     'code',
+    'extension',
 ];
 export const EDITOR_BLOCK_TYPES = [
     'paragraph',

package/dist/focus-scope/focus-scope.d.ts

@@ -20,6 +20,13 @@ export interface FocusScopeOptions {
     cycleTabNavigation?: boolean;
     /** Called before focus returns to the opener; call `preventDefault()` to cancel. */
     onBeforeRestoreFocus?: (event: FocusRestoreEvent) => void;
+    /**
+     * Focus-exempt regions outside the container (an undo toaster, the live
+     * announcer). While focus is inside one, Tab and Shift+Tab move natively
+     * between the region's own stops; past its last (or before its first) stop,
+     * focus wraps back into the scope. Queried on every Tab.
+     */
+    exemptRegions?: () => readonly Element[];
 }
 /** An activated, framework-free keyboard focus scope. */
 export interface FocusScope {

package/dist/focus-scope/focus-scope.js

@@ -44,11 +44,35 @@ export function createFocusScope(container, options = {}) {
             return;
         focus(resolveInitialTarget(container, options), true);
     };
+    /** The exempt region holding `node`, when it sits outside the container. */
+    const exemptRegionOf = (node) => {
+        if (!node || container.contains(node))
+            return null;
+        for (const region of options.exemptRegions?.() ?? []) {
+            if (region.contains(node))
+                return region;
+        }
+        return null;
+    };
     const onKeyDown = (event) => {
         if (!active || !isTopScope(scope, document) || event.key !== 'Tab')
             return;
         const tabbable = getTabbableElements(container);
         const current = document.activeElement;
+        const region = exemptRegionOf(current);
+        if (region) {
+            // Inside a focus-exempt region: native order between its own stops,
+            // then back into the scope at either end.
+            const stops = getTabbableElements(region);
+            const at = stops.indexOf(current);
+            const leaving = event.shiftKey ? at <= 0 : at < 0 || at === stops.length - 1;
+            if (!leaving)
+                return;
+            event.preventDefault();
+            const target = event.shiftKey ? tabbable[tabbable.length - 1] : tabbable[0];
+            focus(target ?? container, !target);
+            return;
+        }
         const index = tabbable.indexOf(current);
         const cycle = options.cycleTabNavigation === true;
         if (!cycle && !(event.shiftKey ? index <= 0 : index < 0 || index === tabbable.length - 1)) {

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export { lockScroll } from './scroll-lock/scroll-lock.js';
 export type { TabbableOptions } from './tabbable/index.js';
 export { getFocusableElements, getTabbableElements, isFocusable, isTabbable, } from './tabbable/index.js';
 export { type HrefTrust, safeHref } from './url/safe-href.js';
+export { filterImageSrcset } from './url-policy/filter-image-srcset.js';
 export { safeImageSrc } from './url-policy/safe-image-src.js';
 export { safeImageSrcset } from './url-policy/safe-image-srcset.js';
 export { type SafeMediaSrcOptions, safeMediaSrc } from './url-policy/safe-media-src.js';

package/dist/index.js

@@ -18,6 +18,7 @@ export { createRovingFocus, createTypeahead, indexOfSelected, isItemDisabled, se
 export { lockScroll } from "./scroll-lock/scroll-lock.js";
 export { getFocusableElements, getTabbableElements, isFocusable, isTabbable, } from "./tabbable/index.js";
 export { safeHref } from "./url/safe-href.js";
+export { filterImageSrcset } from "./url-policy/filter-image-srcset.js";
 export { safeImageSrc } from "./url-policy/safe-image-src.js";
 export { safeImageSrcset } from "./url-policy/safe-image-srcset.js";
 export { safeMediaSrc } from "./url-policy/safe-media-src.js";

package/dist/inert/inert.d.ts

@@ -34,10 +34,21 @@ export interface InertExemptionInput {
     element: Element;
     /** Optional debug label (`toast-region`, `announcer`, …). */
     label?: string;
+    /**
+     * Whether the region stays above overlays opened after it (default `true`):
+     * when it is open as a popover, the overlay engine re-shows it in the top
+     * layer each time another overlay opens, so the toast region keeps painting
+     * on top. Pass `false` for exemptions that belong under later overlays: a
+     * dialog backdrop, or a menu or listbox opened inside a modal, which must
+     * never cover the overlay opened from it.
+     */
+    raise?: boolean;
 }
 export interface InertExemption {
     readonly element: Element;
     readonly label?: string;
+    /** `false` when the region must not be re-raised above later overlays (omitted means `true`). */
+    readonly raise?: false;
 }
 export interface InertExemptionHandle {
     /** Stop exempting this element (idempotent). Open scopes recompute. */

package/dist/inert/inert.js

@@ -30,8 +30,15 @@ const SKIPPED_TAGS = new Set([
     'TEMPLATE',
     'TITLE',
 ]);
+// Realm-independent: an element from another window, or one whose timer runs
+// after the global Element binding is gone, is still an element.
 function isElement(value) {
-    return typeof Element !== 'undefined' && value instanceof Element;
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const node = value;
+    return (node.nodeType === 1 &&
+        typeof node.setAttribute === 'function' &&
+        typeof node.contains === 'function');
 }
 /**
  * The elements to make inert so that only `keep` (and their descendants) stay
@@ -135,9 +142,11 @@ export function createInertRegistry() {
             if (!isElement(input.element)) {
                 throw new TypeError('InertRegistry.exempt: element must be a DOM Element');
             }
-            const entry = input.label === undefined
-                ? { element: input.element }
-                : { element: input.element, label: input.label };
+            const entry = {
+                element: input.element,
+                ...(input.label === undefined ? {} : { label: input.label }),
+                ...(input.raise === false ? { raise: false } : {}),
+            };
             exemptions.push(entry);
             apply();
             let released = false;

package/dist/markup/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @texuli/core/markup: escaped XML and HTML builders (ADR-016). Typed nodes
+ * only, no raw-markup API; URL attributes go through the URL policy.
+ */
+export { el, escapeMarkupAttribute, escapeMarkupText, HTML_ELEMENTS, HTML_URL_ATTRIBUTES, type HtmlSerializeOptions, imageUrl, isMarkupUrl, linkUrl, type MarkupAttribute, type MarkupAttributeValue, type MarkupChild, type MarkupElement, type MarkupNode, type MarkupText, type MarkupUrl, sanitizeMarkupChars, serializeHtml, serializeXml, text, type XmlSerializeOptions, } from './markup.js';

package/dist/markup/index.js

@@ -0,0 +1,5 @@
+/**
+ * @texuli/core/markup: escaped XML and HTML builders (ADR-016). Typed nodes
+ * only, no raw-markup API; URL attributes go through the URL policy.
+ */
+export { el, escapeMarkupAttribute, escapeMarkupText, HTML_ELEMENTS, HTML_URL_ATTRIBUTES, imageUrl, isMarkupUrl, linkUrl, sanitizeMarkupChars, serializeHtml, serializeXml, text, } from "./markup.js";

package/dist/markup/markup.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Escaped markup builders (ADR-016): typed element and text nodes that
+ * serialize to XML or HTML. Content only enters through these nodes, so
+ * there is no raw-markup API: every text and attribute value is escaped,
+ * element and attribute names are checked, and URL-valued HTML attributes
+ * accept only a `MarkupUrl` made by `linkUrl` or `imageUrl`, which call the
+ * URL policy with an explicit tier. Serialization is iterative and linear in
+ * the size of the tree.
+ */
+import { type HrefTrust } from '../url/safe-href.js';
+export interface MarkupText {
+    readonly kind: 'text';
+    readonly value: string;
+}
+/** A URL that passed the URL policy. Only `linkUrl` and `imageUrl` make one the serializers accept. */
+export interface MarkupUrl {
+    readonly kind: 'url';
+    readonly value: string;
+}
+export type MarkupAttributeValue = string | number | boolean | MarkupUrl | null | undefined;
+export type MarkupAttribute = readonly [string, string | boolean | MarkupUrl];
+export interface MarkupElement {
+    readonly kind: 'element';
+    readonly name: string;
+    readonly attributes: readonly MarkupAttribute[];
+    readonly children: readonly MarkupNode[];
+}
+export type MarkupNode = MarkupElement | MarkupText;
+/** A child: a node, a string or number (escaped text), a nested list, or a skipped `null`, `undefined` or `false`. */
+export type MarkupChild = MarkupNode | string | number | null | undefined | false | readonly MarkupChild[];
+export interface XmlSerializeOptions {
+    /** Prefix the UTF-8 declaration (`standalone="yes"`, as Office packages use). Default true. */
+    declaration?: boolean;
+    /** An allowlist for element and attribute names, on top of the XML name grammar. */
+    allow?: (name: string, what: 'element' | 'attribute') => boolean;
+}
+export interface HtmlSerializeOptions {
+    /** Prefix `<!doctype html>`. Default false. */
+    doctype?: boolean;
+}
+/**
+ * The HTML elements `serializeHtml` writes: document structure, text,
+ * lists, tables, links and images. No scripts, styles, frames, objects,
+ * forms, templates, SVG or MathML.
+ */
+export declare const HTML_ELEMENTS: ReadonlySet<string>;
+/** HTML attributes that hold a URL: only a `MarkupUrl` value is written. */
+export declare const HTML_URL_ATTRIBUTES: ReadonlySet<string>;
+/** A link URL through `safeHref` at `trust`, or `null` when the policy refuses it. */
+export declare function linkUrl(value: string, trust: HrefTrust): MarkupUrl | null;
+/** An image URL through `safeImageSrc` at `trust`, or `null` when the policy refuses it. */
+export declare function imageUrl(value: string, trust: HrefTrust): MarkupUrl | null;
+/** True only for a URL `linkUrl` or `imageUrl` made (a hand-built object is not one). */
+export declare function isMarkupUrl(value: unknown): value is MarkupUrl;
+/**
+ * Drop characters XML 1.0 cannot carry: C0 controls other than tab,
+ * newline and carriage return, U+FFFE and U+FFFF, and unpaired surrogates.
+ */
+export declare function sanitizeMarkupChars(value: string): string;
+export declare function escapeMarkupText(value: string): string;
+export declare function escapeMarkupAttribute(value: string): string;
+export declare function text(value: string | number): MarkupText;
+/** Build an element. String and number children become escaped text; nullish and `false` children are skipped. */
+export declare function el(name: string, attributes?: Readonly<Record<string, MarkupAttributeValue>>, ...children: MarkupChild[]): MarkupElement;
+/** Serialize to XML: booleans become `1` and `0` (the Office convention); childless elements self-close. */
+export declare function serializeXml(root: MarkupElement, options?: XmlSerializeOptions): string;
+/**
+ * Serialize to HTML: only `HTML_ELEMENTS`, no event handler or `srcdoc`
+ * attributes, URL attributes only from `linkUrl` or `imageUrl`, booleans as
+ * bare attributes, and void elements without an end tag.
+ */
+export declare function serializeHtml(root: MarkupElement, options?: HtmlSerializeOptions): string;

package/dist/markup/markup.js

@@ -0,0 +1,233 @@
+/**
+ * Escaped markup builders (ADR-016): typed element and text nodes that
+ * serialize to XML or HTML. Content only enters through these nodes, so
+ * there is no raw-markup API: every text and attribute value is escaped,
+ * element and attribute names are checked, and URL-valued HTML attributes
+ * accept only a `MarkupUrl` made by `linkUrl` or `imageUrl`, which call the
+ * URL policy with an explicit tier. Serialization is iterative and linear in
+ * the size of the tree.
+ */
+import { safeHref } from "../url/safe-href.js";
+import { safeImageSrc } from "../url-policy/safe-image-src.js";
+const XML_NAME = /^[A-Za-z_][A-Za-z0-9._-]*(?::[A-Za-z_][A-Za-z0-9._-]*)?$/;
+const HTML_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const HTML_ATTRIBUTE = /^[a-z][a-z0-9]*(?:[-:][a-z0-9]+)*$/;
+/**
+ * The HTML elements `serializeHtml` writes: document structure, text,
+ * lists, tables, links and images. No scripts, styles, frames, objects,
+ * forms, templates, SVG or MathML.
+ */
+export const HTML_ELEMENTS = new Set(('html head body title meta main article section header footer nav aside div span p br hr ' +
+    'h1 h2 h3 h4 h5 h6 strong b em i u s del ins code pre kbd samp small sub sup mark blockquote ' +
+    'q cite abbr time ul ol li dl dt dd a img figure figcaption table caption thead tbody tfoot ' +
+    'tr th td colgroup col center font address details summary wbr').split(' '));
+/** HTML elements written without children or an end tag. */
+const HTML_VOID = new Set(['br', 'hr', 'img', 'meta', 'col', 'wbr']);
+/** HTML attributes that hold a URL: only a `MarkupUrl` value is written. */
+export const HTML_URL_ATTRIBUTES = new Set(('href src srcset action formaction poster cite data background xlink:href ping manifest ' +
+    'codebase longdesc usemap lowsrc dynsrc').split(' '));
+/** HTML attributes no output carries: event handlers are refused by prefix, these by name. */
+const HTML_DENIED_ATTRIBUTES = new Set(['srcdoc', 'http-equiv', 'is', 'nonce']);
+const urls = new WeakSet();
+function makeUrl(value) {
+    if (value === undefined)
+        return null;
+    const url = Object.freeze({ kind: 'url', value });
+    urls.add(url);
+    return url;
+}
+/** A link URL through `safeHref` at `trust`, or `null` when the policy refuses it. */
+export function linkUrl(value, trust) {
+    return makeUrl(safeHref(value, trust));
+}
+/** An image URL through `safeImageSrc` at `trust`, or `null` when the policy refuses it. */
+export function imageUrl(value, trust) {
+    return makeUrl(safeImageSrc(value, trust));
+}
+/** True only for a URL `linkUrl` or `imageUrl` made (a hand-built object is not one). */
+export function isMarkupUrl(value) {
+    return typeof value === 'object' && value !== null && urls.has(value);
+}
+/**
+ * Drop characters XML 1.0 cannot carry: C0 controls other than tab,
+ * newline and carriage return, U+FFFE and U+FFFF, and unpaired surrogates.
+ */
+export function sanitizeMarkupChars(value) {
+    // Fast path: most text has nothing to drop.
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: matching the controls is the point.
+    if (!/[\u0000-\u0008\u000b\u000c\u000e-\u001f\ud800-\udfff￾￿]/.test(value))
+        return value;
+    let out = '';
+    for (const character of value) {
+        const code = character.codePointAt(0) ?? 0;
+        if (code === 0x09 || code === 0x0a || code === 0x0d)
+            out += character;
+        else if (code < 0x20 || code === 0xfffe || code === 0xffff)
+            continue;
+        else if (code >= 0xd800 && code <= 0xdfff)
+            continue;
+        else
+            out += character;
+    }
+    return out;
+}
+export function escapeMarkupText(value) {
+    return sanitizeMarkupChars(value)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+export function escapeMarkupAttribute(value) {
+    return escapeMarkupText(value)
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;')
+        .replace(/\t/g, '&#9;')
+        .replace(/\n/g, '&#10;')
+        .replace(/\r/g, '&#13;');
+}
+export function text(value) {
+    return { kind: 'text', value: String(value) };
+}
+function pushChildren(out, children) {
+    // Iterative flattening, so a deeply nested child list cannot overflow the stack.
+    const stack = [children, 0];
+    while (stack.length > 0) {
+        const index = stack.pop();
+        const list = stack.pop();
+        if (index >= list.length)
+            continue;
+        stack.push(list, index + 1);
+        const child = list[index];
+        if (child === null || child === undefined || child === false)
+            continue;
+        if (Array.isArray(child))
+            stack.push(child, 0);
+        else if (typeof child === 'string' || typeof child === 'number')
+            out.push(text(child));
+        else
+            out.push(child);
+    }
+}
+function assertXmlName(name, what) {
+    if (typeof name !== 'string' || !XML_NAME.test(name)) {
+        throw new TypeError(`Invalid markup ${what} name: ${JSON.stringify(name)}`);
+    }
+}
+/** Build an element. String and number children become escaped text; nullish and `false` children are skipped. */
+export function el(name, attributes = {}, ...children) {
+    assertXmlName(name, 'element');
+    const attrs = [];
+    for (const key of Object.keys(attributes)) {
+        const value = attributes[key];
+        if (value === undefined || value === null)
+            continue;
+        assertXmlName(key, 'attribute');
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new TypeError(`Attribute ${key} must be a finite number.`);
+            attrs.push([key, String(value)]);
+        }
+        else if (typeof value === 'object') {
+            if (!isMarkupUrl(value))
+                throw new TypeError(`Attribute ${key} holds an unchecked URL object.`);
+            attrs.push([key, value]);
+        }
+        else
+            attrs.push([key, value]);
+    }
+    const nodes = [];
+    pushChildren(nodes, children);
+    return { kind: 'element', name, attributes: attrs, children: nodes };
+}
+function walk(root, open, close, leaf) {
+    if (root.kind === 'text')
+        return leaf(root);
+    const parts = [open(root)];
+    const stack = [{ node: root, index: 0 }];
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const child = frame.node.children[frame.index];
+        if (child === undefined) {
+            parts.push(close(frame.node));
+            stack.pop();
+            continue;
+        }
+        frame.index += 1;
+        if (child.kind === 'text')
+            parts.push(leaf(child));
+        else if (child.kind === 'element') {
+            parts.push(open(child));
+            stack.push({ node: child, index: 0 });
+        }
+        else
+            throw new TypeError('Unknown markup node.');
+    }
+    return parts.join('');
+}
+/** Serialize to XML: booleans become `1` and `0` (the Office convention); childless elements self-close. */
+export function serializeXml(root, options = {}) {
+    const allow = options.allow;
+    const check = (name, what) => {
+        assertXmlName(name, what);
+        if (allow && !allow(name, what)) {
+            throw new TypeError(`Markup ${what} not allowed: ${JSON.stringify(name)}`);
+        }
+    };
+    const body = walk(root, (node) => {
+        // Re-check names, so a hand-built node object cannot smuggle markup.
+        check(node.name, 'element');
+        let out = `<${node.name}`;
+        for (const [key, value] of node.attributes) {
+            check(key, 'attribute');
+            const raw = typeof value === 'boolean' ? (value ? '1' : '0') : xmlValue(value);
+            out += ` ${key}="${escapeMarkupAttribute(raw)}"`;
+        }
+        return node.children.length === 0 ? `${out}/>` : `${out}>`;
+    }, (node) => (node.children.length === 0 ? '' : `</${node.name}>`), (node) => escapeMarkupText(String(node.value)));
+    return options.declaration === false
+        ? body
+        : `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${body}`;
+}
+function xmlValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!isMarkupUrl(value))
+        throw new TypeError('Unchecked URL object in markup.');
+    return value.value;
+}
+function htmlAttribute(name, value) {
+    if (!HTML_ATTRIBUTE.test(name) || name.startsWith('on') || HTML_DENIED_ATTRIBUTES.has(name)) {
+        throw new TypeError(`HTML attribute not allowed: ${JSON.stringify(name)}`);
+    }
+    if (HTML_URL_ATTRIBUTES.has(name)) {
+        if (!isMarkupUrl(value)) {
+            throw new TypeError(`HTML attribute ${name} takes a URL from linkUrl or imageUrl.`);
+        }
+        return ` ${name}="${escapeMarkupAttribute(value.value)}"`;
+    }
+    if (typeof value === 'boolean')
+        return value ? ` ${name}` : '';
+    if (typeof value !== 'string')
+        throw new TypeError(`HTML attribute ${name} is not text.`);
+    return ` ${name}="${escapeMarkupAttribute(value)}"`;
+}
+/**
+ * Serialize to HTML: only `HTML_ELEMENTS`, no event handler or `srcdoc`
+ * attributes, URL attributes only from `linkUrl` or `imageUrl`, booleans as
+ * bare attributes, and void elements without an end tag.
+ */
+export function serializeHtml(root, options = {}) {
+    const body = walk(root, (node) => {
+        if (!HTML_NAME.test(node.name) || !HTML_ELEMENTS.has(node.name)) {
+            throw new TypeError(`HTML element not allowed: ${JSON.stringify(node.name)}`);
+        }
+        if (HTML_VOID.has(node.name) && node.children.length > 0) {
+            throw new TypeError(`HTML element ${node.name} takes no children.`);
+        }
+        let out = `<${node.name}`;
+        for (const [key, value] of node.attributes)
+            out += htmlAttribute(key, value);
+        return `${out}>`;
+    }, (node) => (HTML_VOID.has(node.name) ? '' : `</${node.name}>`), (node) => escapeMarkupText(String(node.value)));
+    return options.doctype ? `<!doctype html>${body}` : body;
+}