@vamos-ui/react 0.0.0-stage → 0.2.0

package/dist/blocks/labels.js

@@ -0,0 +1,43 @@
+// Built-in strings for site blocks (D2b). Server-safe: no context — pass `labels` or use createBlocks.
+import { formatMessage } from "../lib/message-format.js";
+/** English defaults. Keys are shared by every site block; wave-3 blocks add theirs here. */
+export const blockLabels = {
+    opensInNewTab: "(opens in a new tab)",
+    skipToContent: "Skip to content",
+    addTitle: "Add a title",
+    addText: "Add text",
+    addImage: "Add an image",
+    unknownBlock: "Unknown block “{type}”",
+    unknownBlockHint: "This block type is not installed. Its content is kept and will render again once the block is available.",
+    invalidBlock: "“{type}” has invalid content",
+    invalidBlockHint: "{count, plural, one {# field was} other {# fields were}} replaced with defaults. Fix them in the editor.",
+    newerBlock: "“{type}” was saved by a newer version (v{v})",
+    emptyImage: "No image",
+    codeSample: "Code sample",
+};
+/** Turkish dictionary for site blocks. */
+export const blockLabelsTr = {
+    opensInNewTab: "(yeni sekmede açılır)",
+    skipToContent: "İçeriğe geç",
+    addTitle: "Başlık ekleyin",
+    addText: "Metin ekleyin",
+    addImage: "Görsel ekleyin",
+    unknownBlock: "Bilinmeyen blok “{type}”",
+    unknownBlockHint: "Bu blok türü kurulu değil. İçeriği korunuyor; blok yeniden eklendiğinde görünecek.",
+    invalidBlock: "“{type}” geçersiz içerik barındırıyor",
+    invalidBlockHint: "{count} alan varsayılan değerle değiştirildi. Düzenleyicide düzeltin.",
+    newerBlock: "“{type}” daha yeni bir sürümle kaydedilmiş (v{v})",
+    emptyImage: "Görsel yok",
+    codeSample: "Kod örneği",
+};
+/** Label lookup for server components: `labels` prop → English. */
+export function blockText(labels, locale = "en-US") {
+    const merged = { ...blockLabels };
+    if (labels)
+        for (const k in labels) {
+            const v = labels[k];
+            if (typeof v === "string")
+                merged[k] = v;
+        }
+    return (key, vars) => formatMessage(merged[key], vars, locale);
+}

package/dist/blocks/rich-text.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { type RichBlock, type RichDoc, type RichInline } from "./schema/rich-doc.js";
+import { type BlockLabels } from "./labels.js";
+import type { BlockAdapters } from "./types.js";
+export interface RichTextRenderOptions {
+    components?: BlockAdapters;
+    labels?: Partial<BlockLabels>;
+    locale?: string;
+    /** Shift stored heading levels: 1 renders h2 as h3 (inside a block whose title is h2). */
+    headingOffset?: 0 | 1 | 2;
+}
+/** Renders inline runs. Consecutive runs with the same link share one `<a>`. */
+export declare function renderInline(content: readonly RichInline[] | undefined, opts?: RichTextRenderOptions, keyPrefix?: string): React.ReactNode;
+/** Renders RichDoc blocks (no wrapper). */
+export declare function renderRichBlocks(blocks: readonly RichBlock[], opts?: RichTextRenderOptions, keyPrefix?: string): React.ReactNode;
+export interface RichTextProps extends RichTextRenderOptions, Omit<React.HTMLAttributes<HTMLDivElement>, "content"> {
+    /** A RichDoc, a list of RichDoc blocks, inline runs, or plain text (blank line = new paragraph). */
+    doc?: RichDoc | readonly RichBlock[] | readonly RichInline[] | string;
+    /** Text size: 14 / 16 / 18 px. Default `"md"`. */
+    size?: "sm" | "md" | "lg";
+    /** Remove the reading-width cap (64ch). */
+    fullWidth?: boolean;
+    editMode?: boolean;
+    /** Prop path for edit mode (`data-field`). */
+    field?: string;
+}
+/**
+ * Pure server renderer for the RichDoc format (paragraphs, h2–h4, lists, quotes, code, rules +
+ * bold, italic, underline, strike, code, highlight, sub/sup, links). No editor code reaches the
+ * site. Links are sanitised and routed through `components.Link`.
+ *
+ * ```tsx
+ * <RichText doc={props.body} components={{ Link: NextLink }} />
+ * ```
+ */
+export declare function RichText({ doc, components, labels, locale, headingOffset, size, fullWidth, editMode, field, className, ...props }: RichTextProps): React.JSX.Element | null;

package/dist/blocks/rich-text.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../lib/cn.js";
+import { BlockLink } from "./block-link.js";
+import { isBreak, richFromText } from "./schema/rich-doc.js";
+import { blockText } from "./labels.js";
+const MARK_ORDER = ["bold", "italic", "underline", "strike", "highlight", "code", "sub", "sup"];
+const markTag = { bold: "strong", italic: "em", underline: "u", strike: "s", highlight: "mark", code: "code", sub: "sub", sup: "sup" };
+function textWithBreaks(text, key) {
+    if (!text.includes("\n"))
+        return text;
+    return text.split("\n").map((line, i) => (_jsxs(React.Fragment, { children: [i > 0 ? _jsx("br", {}) : null, line] }, `${key}-${i}`)));
+}
+function renderRun(run, key) {
+    let node = textWithBreaks(run.text, key);
+    const types = new Set((run.marks ?? []).map((m) => m.type));
+    // innermost first so the nesting is always strong > em > u > s > mark > code > sub/sup
+    for (const m of [...MARK_ORDER].reverse()) {
+        if (types.has(m)) {
+            const Tag = markTag[m];
+            node = _jsx(Tag, { children: node }, `${key}-${m}`);
+        }
+    }
+    return node;
+}
+const linkOf = (n) => (isBreak(n) ? undefined : n.marks?.find((m) => m.type === "link"));
+const sameLink = (a, b) => !!a && !!b && a.href === b.href && !!a.newTab === !!b.newTab;
+/** Renders inline runs. Consecutive runs with the same link share one `<a>`. */
+export function renderInline(content, opts = {}, keyPrefix = "i") {
+    if (!content?.length)
+        return null;
+    const out = [];
+    for (let i = 0; i < content.length; i++) {
+        const n = content[i];
+        const key = `${keyPrefix}${i}`;
+        if (isBreak(n)) {
+            out.push(_jsx("br", {}, key));
+            continue;
+        }
+        const link = linkOf(n);
+        if (!link) {
+            out.push(_jsx(React.Fragment, { children: renderRun(n, key) }, key));
+            continue;
+        }
+        const group = [renderRun(n, key)];
+        while (i + 1 < content.length && sameLink(link, linkOf(content[i + 1]))) {
+            i++;
+            group.push(_jsx(React.Fragment, { children: renderRun(content[i], `${keyPrefix}${i}`) }, `${keyPrefix}${i}`));
+        }
+        out.push(_jsx(BlockLink, { href: link.href, newTab: link.newTab, title: link.title, components: opts.components, labels: opts.labels, locale: opts.locale, children: group }, key));
+    }
+    return out;
+}
+/** Renders RichDoc blocks (no wrapper). */
+export function renderRichBlocks(blocks, opts = {}, keyPrefix = "b") {
+    return blocks.map((b, i) => {
+        const key = `${keyPrefix}${i}`;
+        switch (b.type) {
+            case "paragraph":
+                return b.content?.length ? _jsx("p", { children: renderInline(b.content, opts, `${key}-`) }, key) : null;
+            case "heading": {
+                const level = Math.min(6, b.level + (opts.headingOffset ?? 0));
+                const Tag = `h${level}`;
+                return (_jsx(Tag, { id: b.anchor, children: renderInline(b.content, opts, `${key}-`) }, key));
+            }
+            case "list": {
+                const items = b.items.map((it, j) => _jsx("li", { children: renderRichBlocks(it.content, opts, `${key}-${j}-`) }, j));
+                return b.ordered ? (_jsx("ol", { start: b.start && b.start !== 1 ? b.start : undefined, children: items }, key)) : (_jsx("ul", { children: items }, key));
+            }
+            case "blockquote":
+                return (_jsxs("blockquote", { children: [renderRichBlocks(b.content, opts, `${key}-`), b.cite ? _jsx("footer", { children: b.cite }) : null] }, key));
+            case "code":
+                return (
+                // Focusable + named so a long line that scrolls sideways is reachable by keyboard.
+                _jsx("pre", { "data-language": b.language, tabIndex: 0, role: "region", "aria-label": b.language ? `${blockText(opts.labels, opts.locale)("codeSample")} (${b.language})` : blockText(opts.labels, opts.locale)("codeSample"), children: _jsx("code", { children: b.text }) }, key));
+            case "hr":
+                return _jsx("hr", {}, key);
+            default:
+                return null;
+        }
+    });
+}
+const isInlineList = (v) => v.length > 0 && v.every((n) => typeof n === "object" && n !== null && ("text" in n || n.type === "br"));
+/**
+ * Pure server renderer for the RichDoc format (paragraphs, h2–h4, lists, quotes, code, rules +
+ * bold, italic, underline, strike, code, highlight, sub/sup, links). No editor code reaches the
+ * site. Links are sanitised and routed through `components.Link`.
+ *
+ * ```tsx
+ * <RichText doc={props.body} components={{ Link: NextLink }} />
+ * ```
+ */
+export function RichText({ doc, components, labels, locale, headingOffset, size = "md", fullWidth, editMode, field, className, ...props }) {
+    if (doc === undefined || doc === null || (typeof doc === "string" && !doc.trim())) {
+        return editMode ? (_jsx("div", { "data-field": field, "data-empty": "", className: cn("prose-ui vb-prose text-fg-subtle", className), ...props, children: _jsx("p", { children: blockText(labels, locale)("addText") }) })) : null;
+    }
+    const opts = { components, labels, locale, headingOffset };
+    let body;
+    if (typeof doc === "string")
+        body = renderRichBlocks(richFromText(doc).content, opts);
+    else if (Array.isArray(doc))
+        body = isInlineList(doc) ? _jsx("p", { children: renderInline(doc, opts) }) : renderRichBlocks(doc, opts);
+    else
+        body = renderRichBlocks(doc.content ?? [], opts);
+    return (_jsx("div", { "data-slot": "rich-text", "data-field": editMode ? field : undefined, className: cn("prose-ui vb-prose", size === "sm" && "prose-ui-sm", size === "lg" && "prose-ui-lg", fullWidth && "max-w-none", className), ...props, children: body }));
+}

package/dist/blocks/schema/define-block.d.ts

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import type * as React from "react";
+import type { BlockNode } from "./types.js";
+import type { BlockComponentProps } from "../types.js";
+import type { LintIssueInput } from "./lint-types.js";
+export type BlockCategory = "intro" | "content" | "media" | "proof" | "conversion" | "local" | "blog" | "site" | "layout" | "text" | "form" | "embed";
+export type BlockRegion = "header" | "body" | "footer" | "overlay";
+/** Removes the `{ [locale]: T }` branch of every Localized<T> — what a component receives after `localize()`. */
+export type Delocalized<T> = T extends string | number | boolean | null | undefined | bigint ? T : T extends readonly (infer U)[] ? Delocalized<U>[] : T extends object ? {
+    [K in keyof T]: Delocalized<DropLocaleMap<T[K]>>;
+} : T;
+type DropLocaleMap<T> = T extends unknown ? (T extends readonly unknown[] ? T : string extends keyof T ? never : T) : never;
+/** Props a registered block's component gets for schema `S`. */
+export type BlockPropsOf<S extends z.ZodType> = Delocalized<z.output<S>>;
+/** Inspector hints per prop (the editor's SchemaForm reads them; `f.*` metadata is the default). */
+export type FieldHints<P> = {
+    [K in keyof P]?: {
+        widget?: string;
+        label?: string;
+        help?: string;
+        placeholder?: string;
+        group?: string;
+        hidden?: boolean;
+    };
+};
+export interface SlotSpec {
+    label?: string;
+    /** Allowed child block types. Default: any body block. */
+    allow?: readonly string[];
+    min?: number;
+    max?: number;
+}
+export interface BlockSupports {
+    /** Editors may set `node.anchor`. Default true. */
+    anchor?: boolean;
+    /** Editors may set `node.theme`. Default true. */
+    theme?: boolean;
+    /** Width options a layout may offer. */
+    align?: readonly ("wide" | "full")[];
+    /** Editors may set `theme.rhythm`. Default true. */
+    spacing?: boolean;
+    /** This block's title is the page title: the first one on a page gets `h1` (hero, page intro). */
+    pageTitle?: boolean;
+}
+export interface JsonLdContext {
+    locale: string;
+    node: BlockNode;
+}
+export interface BlockDefinitionInput<S extends z.ZodObject = z.ZodObject, V extends string = string> {
+    /** Unique, kebab-case, never renamed. */
+    type: string;
+    /** Schema version of `props`. Bump on any breaking change and add a `migrate` step. */
+    version: number;
+    /** Inserter title ("Map & opening hours"). */
+    title: string;
+    description?: string;
+    category: BlockCategory;
+    /** Page region the block belongs to. Default "body". */
+    region?: BlockRegion;
+    /** Inserter search aliases ("banner", "intro"). */
+    keywords?: readonly string[];
+    /** Lucide icon name for the inserter (kebab-case). */
+    icon?: string;
+    variants?: readonly [V, ...V[]];
+    defaultVariant?: V;
+    variantMeta?: Partial<Record<V, {
+        label: string;
+        description?: string;
+        thumb?: string;
+    }>>;
+    /** Props schema (built with `f.*`). Defaults via `.default()`. */
+    schema: S;
+    fields?: FieldHints<z.input<S>>;
+    slots?: Record<string, SlotSpec>;
+    /** `migrate[n]` upgrades props from version n to n + 1. */
+    migrate?: Record<number, (props: any, node: BlockNode) => unknown>;
+    supports?: BlockSupports;
+    /** Inserter preview and the fallback for invalid fields. Realistic copy, never lorem ipsum. */
+    preview?: {
+        props?: z.input<S>;
+        variant?: V;
+        image?: string;
+    };
+    /** Sample content per variant/locale (AI drafts, docs, empty blocks). */
+    examples?: (variant: V, locale: string) => z.input<S>;
+    /** JSON-LD for this block; the renderer merges every block into one @graph. */
+    jsonLd?: (props: BlockPropsOf<S>, ctx: JsonLdContext) => Record<string, unknown> | Record<string, unknown>[] | null;
+    /** Block-specific lint rules (D6). */
+    lint?: (props: BlockPropsOf<S>, node: BlockNode) => LintIssueInput[];
+    /** The SAME component on the site and in the editor canvas. Omit for schema-only (server) registries. */
+    component?: React.ComponentType<BlockComponentProps<BlockPropsOf<S>>>;
+}
+export interface BlockDefinition<S extends z.ZodObject = z.ZodObject, V extends string = string> extends BlockDefinitionInput<S, V> {
+    readonly region: BlockRegion;
+    readonly supports: BlockSupports;
+    /** Strict node schema for this type. */
+    readonly nodeSchema: z.ZodType<BlockNode>;
+    /** Example props for a variant (preview → examples → schema defaults). */
+    sample(variant?: V, locale?: string): z.input<S>;
+}
+/** A block definition with any props schema (registries, renderers). */
+export type AnyBlockDefinition = BlockDefinition<any, any>;
+export declare class BlockDefinitionError extends Error {
+    constructor(type: string, message: string);
+}
+/**
+ * Defines a block once for the site, the editor and JSON tooling.
+ *
+ * ```ts
+ * export const faqBlock = defineBlock({
+ *   type: "faq", version: 1, title: "FAQ", category: "content",
+ *   schema: z.object({ title: f.heading(), items: f.list(f.group({ q: f.text(), a: f.rich() }), { min: 1 }) }),
+ *   preview: { props: { title: "Before you *book*", items: [...] } },
+ *   component: Faq,
+ * });
+ * ```
+ */
+export declare function defineBlock<S extends z.ZodObject, const V extends string = string>(def: BlockDefinitionInput<S, V>): BlockDefinition<S, V>;
+export interface BlockRegistry {
+    readonly definitions: readonly AnyBlockDefinition[];
+    readonly types: readonly string[];
+    get(type: string): AnyBlockDefinition | undefined;
+    has(type: string): boolean;
+    /** True for registered types and the core text types (paragraph, heading…). */
+    knows(type: string): boolean;
+    list(filter?: {
+        region?: BlockRegion;
+        category?: BlockCategory;
+    }): AnyBlockDefinition[];
+    /** A new registry with more blocks (later definitions win only when `override` is set). */
+    extend(defs: readonly AnyBlockDefinition[], opts?: {
+        override?: boolean;
+    }): BlockRegistry;
+    /** Strict node schema: a discriminated union of every registered type (core text types pass loosely). */
+    nodeSchema(): z.ZodType<BlockNode>;
+    /** Strict VamosDoc schema for this registry. */
+    docSchema(): z.ZodType;
+    /** JSON Schema of the doc format with every block's props (LLM tool definitions, external builders). */
+    toJSONSchema(opts?: {
+        target?: "doc" | "node";
+    }): Record<string, unknown>;
+}
+/**
+ * Collects block definitions. Tree-shakeable: import only the blocks a site uses.
+ *
+ * ```ts
+ * export const siteBlocks = createRegistry([heroBlock, faqBlock, ctaBlock]);
+ * ```
+ */
+export declare function createRegistry(defs?: readonly AnyBlockDefinition[]): BlockRegistry;
+export {};

package/dist/blocks/schema/define-block.js

@@ -0,0 +1,120 @@
+// defineBlock + registry: ONE definition per block, shared by the site renderer, the block
+// editor (inspector, inserter, slots) and AI/JSON tooling (X6). React appears only as a type.
+import { z } from "zod";
+import { blockNodeBase, docSchemaOf, BlockNodeSchema, isCoreTextType, VAMOS_DOC_SCHEMA_URL } from "./nodes.js";
+export class BlockDefinitionError extends Error {
+    constructor(type, message) {
+        super(`defineBlock("${type}"): ${message}`);
+        this.name = "BlockDefinitionError";
+    }
+}
+/**
+ * Defines a block once for the site, the editor and JSON tooling.
+ *
+ * ```ts
+ * export const faqBlock = defineBlock({
+ *   type: "faq", version: 1, title: "FAQ", category: "content",
+ *   schema: z.object({ title: f.heading(), items: f.list(f.group({ q: f.text(), a: f.rich() }), { min: 1 }) }),
+ *   preview: { props: { title: "Before you *book*", items: [...] } },
+ *   component: Faq,
+ * });
+ * ```
+ */
+export function defineBlock(def) {
+    if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(def.type))
+        throw new BlockDefinitionError(def.type, "type must be kebab-case.");
+    if (!Number.isInteger(def.version) || def.version < 1)
+        throw new BlockDefinitionError(def.type, "version must be a positive integer.");
+    for (const k of Object.keys(def.migrate ?? {})) {
+        const n = Number(k);
+        if (!Number.isInteger(n) || n < 1 || n >= def.version)
+            throw new BlockDefinitionError(def.type, `migrate[${k}] must upgrade a version below ${def.version}.`);
+    }
+    for (let n = 1; n < def.version; n++) {
+        if (!def.migrate?.[n])
+            throw new BlockDefinitionError(def.type, `missing migrate[${n}] (v${n} → v${n + 1}); stored content would be lost.`);
+    }
+    if (def.defaultVariant && def.variants && !def.variants.includes(def.defaultVariant))
+        throw new BlockDefinitionError(def.type, `defaultVariant "${def.defaultVariant}" is not in variants.`);
+    const variantSchema = def.variants ? z.enum(def.variants).optional() : z.string().optional();
+    const nodeSchema = z.object({
+        ...blockNodeBase,
+        type: z.literal(def.type),
+        variant: variantSchema,
+        props: def.schema,
+        slots: z.record(z.string(), z.array(BlockNodeSchema)).optional(),
+    });
+    const out = {
+        ...def,
+        region: def.region ?? "body",
+        supports: { anchor: true, theme: true, spacing: true, ...def.supports },
+        nodeSchema,
+        sample(variant, locale = "en") {
+            if (variant && def.examples)
+                return def.examples(variant, locale);
+            if (def.preview?.props)
+                return def.preview.props;
+            const v = (variant ?? def.defaultVariant ?? def.variants?.[0]);
+            if (def.examples)
+                return def.examples(v, locale);
+            const parsed = def.schema.safeParse({});
+            return (parsed.success ? parsed.data : {});
+        },
+    };
+    return Object.freeze(out);
+}
+/**
+ * Collects block definitions. Tree-shakeable: import only the blocks a site uses.
+ *
+ * ```ts
+ * export const siteBlocks = createRegistry([heroBlock, faqBlock, ctaBlock]);
+ * ```
+ */
+export function createRegistry(defs = []) {
+    const map = new Map();
+    for (const d of defs) {
+        if (map.has(d.type))
+            throw new BlockDefinitionError(d.type, "registered twice.");
+        map.set(d.type, d);
+    }
+    let node;
+    const reg = {
+        definitions: [...map.values()],
+        types: [...map.keys()],
+        get: (t) => map.get(t),
+        has: (t) => map.has(t),
+        knows: (t) => map.has(t) || isCoreTextType(t),
+        list: (filter) => [...map.values()].filter((d) => (!filter?.region || d.region === filter.region) && (!filter?.category || d.category === filter.category)),
+        extend(more, opts) {
+            const next = new Map(map);
+            for (const d of more) {
+                if (next.has(d.type) && !opts?.override)
+                    throw new BlockDefinitionError(d.type, "already registered (pass { override: true } to replace it).");
+                next.set(d.type, d);
+            }
+            return createRegistry([...next.values()]);
+        },
+        nodeSchema() {
+            if (node)
+                return node;
+            const strict = [...map.values()].map((d) => d.nodeSchema);
+            const loose = BlockNodeSchema.refine((n) => isCoreTextType(n.type), { message: "Unknown block type." });
+            node = strict.length ? z.union([...strict, loose]) : loose;
+            return node;
+        },
+        docSchema() {
+            return docSchemaOf(reg.nodeSchema());
+        },
+        toJSONSchema(opts) {
+            const target = opts?.target ?? "doc";
+            const strict = [...map.values()].map((d) => d.nodeSchema);
+            const nodeUnion = strict.length > 1 ? z.union(strict) : (strict[0] ?? BlockNodeSchema);
+            const schema = target === "node" ? nodeUnion : docSchemaOf(nodeUnion);
+            const json = z.toJSONSchema(schema, { unrepresentable: "any", io: "input" });
+            if (target === "doc")
+                json.$id = VAMOS_DOC_SCHEMA_URL;
+            return json;
+        },
+    };
+    return reg;
+}

package/dist/blocks/schema/emphasis.d.ts

@@ -0,0 +1,17 @@
+export interface EmphasisPart {
+    text: string;
+    em: boolean;
+}
+/**
+ * Splits a heading string into plain and emphasized parts. `\*` is a literal star; an unmatched
+ * star stays literal; `**` (empty) is ignored.
+ *
+ * ```ts
+ * parseEmphasis("Dinner, *slowly*."); // [{ text: "Dinner, ", em: false }, { text: "slowly", em: true }, { text: ".", em: false }]
+ * ```
+ */
+export declare function parseEmphasis(input: string): EmphasisPart[];
+/** Number of emphasized spans (the schema allows at most one). */
+export declare const countEmphasis: (input: string) => number;
+/** The heading without emphasis markers (for `<title>`, aria-labels, search). */
+export declare const stripEmphasis: (input: string) => string;

package/dist/blocks/schema/emphasis.js

@@ -0,0 +1,69 @@
+// `*emphasis*` in headings: one starred span becomes <em> (italic serif in editorial presets,
+// accent ink in sans presets). Pure, shared by the schema (validation) and BlockHeading (render).
+/**
+ * Splits a heading string into plain and emphasized parts. `\*` is a literal star; an unmatched
+ * star stays literal; `**` (empty) is ignored.
+ *
+ * ```ts
+ * parseEmphasis("Dinner, *slowly*."); // [{ text: "Dinner, ", em: false }, { text: "slowly", em: true }, { text: ".", em: false }]
+ * ```
+ */
+export function parseEmphasis(input) {
+    const parts = [];
+    let buf = "";
+    let i = 0;
+    const push = (text, em) => {
+        if (!text)
+            return;
+        const last = parts[parts.length - 1];
+        if (last && last.em === em)
+            last.text += text;
+        else
+            parts.push({ text, em });
+    };
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === "\\" && input[i + 1] === "*") {
+            buf += "*";
+            i += 2;
+            continue;
+        }
+        if (ch === "*") {
+            // find the closing star (not escaped)
+            let j = i + 1;
+            let inner = "";
+            let closed = false;
+            while (j < input.length) {
+                if (input[j] === "\\" && input[j + 1] === "*") {
+                    inner += "*";
+                    j += 2;
+                    continue;
+                }
+                if (input[j] === "*") {
+                    closed = true;
+                    break;
+                }
+                inner += input[j];
+                j++;
+            }
+            if (closed && inner.trim() && inner === inner.trim()) {
+                push(buf, false);
+                buf = "";
+                push(inner, true);
+                i = j + 1;
+                continue;
+            }
+            buf += "*";
+            i++;
+            continue;
+        }
+        buf += ch;
+        i++;
+    }
+    push(buf, false);
+    return parts;
+}
+/** Number of emphasized spans (the schema allows at most one). */
+export const countEmphasis = (input) => parseEmphasis(input).filter((p) => p.em).length;
+/** The heading without emphasis markers (for `<title>`, aria-labels, search). */
+export const stripEmphasis = (input) => parseEmphasis(input).map((p) => p.text).join("");