@apollohg/react-native-rich-text-editor 2.0.0

package/dist/schemaDocumentConstruction.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructDefaultEmptyDocument = constructDefaultEmptyDocument;
+const contentExpression_1 = require("./contentExpression");
+const schemaNormalization_1 = require("./schemaNormalization");
+function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollections) {
+    const docNode = schema.nodes.find((node) => node.role === 'doc');
+    if (!docNode)
+        throw new Error('schema cannot construct a default document: missing doc role');
+    const budget = { nodes: 0, work: 0, exhausted: false };
+    const workLimit = Math.min(contentExpression_1.DEFAULT_CONTENT_MAX_NODES, resolvedLimits.maxSchemaNodes * 64 + resolvedLimits.maxSchemaExpressionBytes * 32);
+    const consumeWork = () => {
+        if (budget.work >= workLimit) {
+            budget.exhausted = true;
+            return false;
+        }
+        budget.work += 1;
+        return true;
+    };
+    const candidatePriority = (candidate) => {
+        if (candidate.role === 'textBlock' &&
+            (candidate.htmlTag === 'p' || candidate.name === 'paragraph')) {
+            return 0;
+        }
+        return candidate.role === 'textBlock' ? 1 : 2;
+    };
+    const candidatesBySymbol = new Map();
+    let candidateIndexAdmitted = true;
+    const addCandidate = (symbol, candidate) => {
+        if (!consumeWork())
+            return false;
+        const candidates = candidatesBySymbol.get(symbol);
+        if (candidates)
+            candidates.push(candidate);
+        else
+            candidatesBySymbol.set(symbol, [candidate]);
+        return true;
+    };
+    for (const candidate of schema.nodes) {
+        if (!addCandidate(candidate.name, candidate)) {
+            candidateIndexAdmitted = false;
+            break;
+        }
+        for (const group of admittedCollections.groupsByNode.get(candidate) ?? []) {
+            if (group !== candidate.name && !addCandidate(group, candidate)) {
+                candidateIndexAdmitted = false;
+                break;
+            }
+        }
+        if (!candidateIndexAdmitted)
+            break;
+    }
+    for (const candidates of candidatesBySymbol.values()) {
+        const sortingWork = Math.max(candidates.length, Math.ceil(candidates.length * Math.log2(Math.max(2, candidates.length))));
+        for (let index = 0; index < sortingWork; index += 1) {
+            if (!consumeWork()) {
+                candidateIndexAdmitted = false;
+                break;
+            }
+        }
+        if (!candidateIndexAdmitted)
+            break;
+        candidates.sort((left, right) => candidatePriority(left) - candidatePriority(right) ||
+            left.name.localeCompare(right.name));
+    }
+    if (!candidateIndexAdmitted) {
+        throw (0, schemaNormalization_1.schemaBoundaryError)(workLimit, workLimit + 1);
+    }
+    const constructNode = (node, visiting, depth) => {
+        if (depth > Math.min(contentExpression_1.CONTENT_EXPRESSION_MAX_DEPTH, resolvedLimits.maxDocumentDepth) ||
+            !consumeWork()) {
+            return undefined;
+        }
+        if (node.role === 'text' || visiting.has(node.name))
+            return undefined;
+        const attrs = admittedCollections.attrsByNode.get(node) ?? [];
+        for (const _attr of attrs) {
+            if (!consumeWork()) {
+                budget.exhausted = true;
+                return undefined;
+            }
+        }
+        if (attrs.some(([, spec]) => spec.default === undefined)) {
+            return undefined;
+        }
+        visiting.add(node.name);
+        const children = (0, contentExpression_1.minimalContentMatch)(node.content ?? '', (symbol) => {
+            for (const candidate of candidatesBySymbol.get(symbol) ?? []) {
+                if (!consumeWork())
+                    return undefined;
+                const constructed = constructNode(candidate, visiting, depth + 1);
+                if (constructed)
+                    return constructed;
+            }
+            return undefined;
+        }, consumeWork);
+        visiting.delete(node.name);
+        if (!children)
+            return undefined;
+        if (budget.nodes >= resolvedLimits.maxDocumentNodes) {
+            budget.exhausted = true;
+            return undefined;
+        }
+        budget.nodes += 1;
+        const result = { type: node.json?.type ?? node.name };
+        if (children.length > 0)
+            result.content = children;
+        const projectedAttrs = Object.entries(node.json?.attrs ?? {});
+        if (attrs.length > 0 || projectedAttrs.length > 0) {
+            result.attrs = Object.fromEntries([
+                ...attrs.map(([name, spec]) => [name, spec.default]),
+                ...projectedAttrs,
+            ]);
+        }
+        return result;
+    };
+    const document = constructNode(docNode, new Set(), 0);
+    if (!document) {
+        if (budget.exhausted || budget.work >= workLimit) {
+            throw (0, schemaNormalization_1.schemaBoundaryError)(workLimit, workLimit + 1);
+        }
+        throw new Error(`schema cannot construct a default document for '${docNode.name}'`);
+    }
+    return document;
+}

package/dist/schemaNormalization.d.ts

@@ -0,0 +1,29 @@
+import { type NodeSpec, type AttrSpec, type NodeJSONProjection, type NodeHtmlRules, type SchemaDefinition } from './schemaDefinition';
+import { NativeEditorBoundaryError } from './NativeEditorBoundaryError';
+export declare function schemaBoundaryError(limit: number, actual: number): NativeEditorBoundaryError;
+/** Mirror native's invalid-schema fallback before constructing an empty doc. */
+export declare function utf8ByteLengthUpTo(value: string, maximum: number): number;
+export declare function forEachGroupToken(group: string, visit: (token: string) => void, consumeCharacter?: () => boolean, consumeToken?: () => boolean): boolean;
+export interface SchemaWorkBudget {
+    readonly limit: number;
+    work: number;
+    exhausted: boolean;
+}
+export interface AdmittedSchemaCollections {
+    readonly groupsByNode: ReadonlyMap<NodeSpec, readonly string[]>;
+    readonly attrsByNode: ReadonlyMap<NodeSpec, ReadonlyArray<[string, AttrSpec]>>;
+}
+export declare function consumeSchemaWork(budget: SchemaWorkBudget): boolean;
+export declare function consumeSchemaWorkAmount(budget: SchemaWorkBudget, amount: number): boolean;
+export declare function consumeSchemaStringWork(budget: SchemaWorkBudget, value: string): boolean;
+export declare function collectOwnAttrs(value: unknown, budget: SchemaWorkBudget): Array<[string, AttrSpec]> | null;
+export declare function isSafeHtmlTag(tag: string): boolean;
+export declare function isSafeHtmlAttr(name: string): boolean;
+export declare function normalizeAttrs(value: unknown): Record<string, AttrSpec>;
+export declare function normalizeNodeJSONProjection(value: unknown): NodeJSONProjection | null | undefined;
+export declare function isSafeAtomHtmlTag(tag: string): boolean;
+export declare function isSafeAtomHtmlAttr(name: string): boolean;
+export declare function normalizeNodeHtmlRules(value: unknown): NodeHtmlRules | null | undefined;
+export declare function projectionAttrsOverlap(left: Record<string, unknown>, right: Record<string, unknown>): boolean;
+export declare function legacyHeadingProjectionName(projection: NodeJSONProjection): string | undefined;
+export declare function normalizeSchemaDefinition(schema: SchemaDefinition, budget?: SchemaWorkBudget): SchemaDefinition | null;

package/dist/schemaNormalization.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaBoundaryError = schemaBoundaryError;
+exports.utf8ByteLengthUpTo = utf8ByteLengthUpTo;
+exports.forEachGroupToken = forEachGroupToken;
+exports.consumeSchemaWork = consumeSchemaWork;
+exports.consumeSchemaWorkAmount = consumeSchemaWorkAmount;
+exports.consumeSchemaStringWork = consumeSchemaStringWork;
+exports.collectOwnAttrs = collectOwnAttrs;
+exports.isSafeHtmlTag = isSafeHtmlTag;
+exports.isSafeHtmlAttr = isSafeHtmlAttr;
+exports.normalizeAttrs = normalizeAttrs;
+exports.normalizeNodeJSONProjection = normalizeNodeJSONProjection;
+exports.isSafeAtomHtmlTag = isSafeAtomHtmlTag;
+exports.isSafeAtomHtmlAttr = isSafeAtomHtmlAttr;
+exports.normalizeNodeHtmlRules = normalizeNodeHtmlRules;
+exports.projectionAttrsOverlap = projectionAttrsOverlap;
+exports.legacyHeadingProjectionName = legacyHeadingProjectionName;
+exports.normalizeSchemaDefinition = normalizeSchemaDefinition;
+const attributeValidation_1 = require("./attributeValidation");
+const atomPolicy_1 = require("./atomPolicy");
+const schemaDefinition_1 = require("./schemaDefinition");
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+function schemaBoundaryError(limit, actual) {
+    return new NativeEditorBoundaryError_1.NativeEditorBoundaryError('SCHEMA_INVALID', `schema work exceeds configured limit ${limit}`, limit, actual);
+}
+/** Mirror native's invalid-schema fallback before constructing an empty doc. */
+function utf8ByteLengthUpTo(value, maximum) {
+    let bytes = 0;
+    for (const char of value) {
+        const codePoint = char.codePointAt(0) ?? 0;
+        bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+        if (bytes > maximum)
+            return bytes;
+    }
+    return bytes;
+}
+function forEachGroupToken(group, visit, consumeCharacter, consumeToken) {
+    let tokenStart = -1;
+    for (let index = 0; index <= group.length; index += 1) {
+        if (index < group.length && consumeCharacter && !consumeCharacter())
+            return false;
+        const isBoundary = index === group.length || /\s/.test(group[index]);
+        if (!isBoundary && tokenStart < 0)
+            tokenStart = index;
+        if (isBoundary && tokenStart >= 0) {
+            if (consumeToken && !consumeToken())
+                return false;
+            visit(group.slice(tokenStart, index));
+            tokenStart = -1;
+        }
+    }
+    return true;
+}
+function consumeSchemaWork(budget) {
+    return consumeSchemaWorkAmount(budget, 1);
+}
+function consumeSchemaWorkAmount(budget, amount) {
+    if (amount > budget.limit - budget.work) {
+        budget.exhausted = true;
+        return false;
+    }
+    budget.work += amount;
+    return true;
+}
+function consumeSchemaStringWork(budget, value) {
+    return consumeSchemaWorkAmount(budget, utf8ByteLengthUpTo(value, budget.limit) + 1);
+}
+function collectOwnAttrs(value, budget) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    const attrs = [];
+    for (const name in value) {
+        if (!Object.prototype.hasOwnProperty.call(value, name))
+            continue;
+        if (!consumeSchemaWork(budget))
+            return attrs;
+        attrs.push([name, value[name]]);
+    }
+    return attrs;
+}
+function isSafeHtmlTag(tag) {
+    if (tag.length === 0 || tag[0] < 'a' || tag[0] > 'z')
+        return false;
+    for (let index = 1; index < tag.length; index += 1) {
+        const char = tag[index];
+        if (!((char >= 'a' && char <= 'z') || (char >= '0' && char <= '9') || char === '-')) {
+            return false;
+        }
+    }
+    return true;
+}
+function isSafeHtmlAttr(name) {
+    if (name.length === 0)
+        return false;
+    const isAlpha = (char) => (char >= 'A' && char <= 'Z') || (char >= 'a' && char <= 'z');
+    if (!(isAlpha(name[0]) || name[0] === '_' || name[0] === ':'))
+        return false;
+    for (let index = 1; index < name.length; index += 1) {
+        const char = name[index];
+        if (!(isAlpha(char) ||
+            (char >= '0' && char <= '9') ||
+            char === '_' ||
+            char === ':' ||
+            char === '.' ||
+            char === '-')) {
+            return false;
+        }
+    }
+    return true;
+}
+function normalizeAttrs(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([name, rawSpec]) => {
+        if (rawSpec == null || typeof rawSpec !== 'object' || Array.isArray(rawSpec)) {
+            return [name, {}];
+        }
+        (0, attributeValidation_1.validateAttributeSpec)(rawSpec, name);
+        return [
+            name,
+            Object.fromEntries(Object.entries(rawSpec).filter(([, entry]) => entry !== undefined)),
+        ];
+    }));
+}
+function normalizeNodeJSONProjection(value) {
+    if (value === undefined)
+        return undefined;
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const raw = value;
+    if (typeof raw.type !== 'string' || raw.type.length === 0)
+        return null;
+    if (raw.attrs === undefined)
+        return { type: raw.type };
+    if (raw.attrs == null || typeof raw.attrs !== 'object' || Array.isArray(raw.attrs))
+        return null;
+    const attrs = {};
+    for (const [name, attrValue] of Object.entries(raw.attrs)) {
+        if (!isSafeHtmlAttr(name))
+            return null;
+        if (attrValue !== null &&
+            typeof attrValue !== 'string' &&
+            typeof attrValue !== 'boolean' &&
+            !(typeof attrValue === 'number' && Number.isFinite(attrValue))) {
+            return null;
+        }
+        attrs[name] = attrValue;
+    }
+    return Object.keys(attrs).length === 0 ? { type: raw.type } : { type: raw.type, attrs };
+}
+function isSafeAtomHtmlTag(tag) {
+    return atomPolicy_1.ATOM_HTML_IDENTIFIER.test(tag) && !atomPolicy_1.ATOM_HTML_DENIED_TAGS.has(tag);
+}
+function isSafeAtomHtmlAttr(name) {
+    return (atomPolicy_1.ATOM_HTML_IDENTIFIER.test(name) &&
+        !name.startsWith('on') &&
+        !atomPolicy_1.ATOM_HTML_DENIED_ATTRS.has(name));
+}
+function normalizeNodeHtmlRules(value) {
+    if (value === undefined)
+        return undefined;
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const raw = value;
+    if (Object.keys(raw).some((key) => key !== 'tag' && key !== 'staticAttrs' && key !== 'attrMap') ||
+        typeof raw.tag !== 'string' ||
+        !isSafeAtomHtmlTag(raw.tag)) {
+        return null;
+    }
+    const normalizeMap = (candidate, validateName) => {
+        if (candidate === undefined)
+            return undefined;
+        if (candidate == null || typeof candidate !== 'object' || Array.isArray(candidate)) {
+            return null;
+        }
+        const normalized = {};
+        for (const [name, mapped] of Object.entries(candidate)) {
+            if (!validateName(name) || typeof mapped !== 'string')
+                return null;
+            normalized[name] = mapped;
+        }
+        return normalized;
+    };
+    const staticAttrs = normalizeMap(raw.staticAttrs, isSafeAtomHtmlAttr);
+    const attrMap = normalizeMap(raw.attrMap, isSafeHtmlAttr);
+    if (staticAttrs === null ||
+        attrMap === null ||
+        (attrMap != null && Object.values(attrMap).some((name) => !isSafeAtomHtmlAttr(name)))) {
+        return null;
+    }
+    return {
+        tag: raw.tag,
+        ...(staticAttrs == null ? {} : { staticAttrs }),
+        ...(attrMap == null ? {} : { attrMap }),
+    };
+}
+function projectionAttrsOverlap(left, right) {
+    return Object.entries(left).every(([name, value]) => !Object.prototype.hasOwnProperty.call(right, name) || right[name] === value);
+}
+function legacyHeadingProjectionName(projection) {
+    if (projection.type !== 'heading')
+        return undefined;
+    const value = projection.attrs?.level;
+    let level;
+    if (typeof value === 'number' && Number.isInteger(value)) {
+        level = value;
+    }
+    else if (typeof value === 'string' && value.length <= 3 && /^\+?\d+$/.test(value)) {
+        level = Number(value);
+    }
+    return level != null && level >= 1 && level <= 6 ? `h${level}` : undefined;
+}
+function normalizeSchemaDefinition(schema, budget) {
+    const normalizeRole = (role) => {
+        switch (role) {
+            case 'doc':
+            case 'textBlock':
+            case 'list':
+            case 'listItem':
+            case 'text':
+            case 'hardBreak':
+            case 'inline':
+                return role;
+            default:
+                return 'block';
+        }
+    };
+    const nodes = [];
+    for (let nodeIndex = 0; nodeIndex < schema.nodes.length; nodeIndex += 1) {
+        const rawNode = schema.nodes[nodeIndex];
+        if (rawNode == null || typeof rawNode !== 'object' || typeof rawNode.name !== 'string') {
+            return null;
+        }
+        const raw = rawNode;
+        const htmlTag = typeof raw.htmlTag === 'string' ? raw.htmlTag : undefined;
+        const html = normalizeNodeHtmlRules(raw.html);
+        const attrs = normalizeAttrs(raw.attrs);
+        const json = normalizeNodeJSONProjection(raw.json);
+        if ((htmlTag != null && !isSafeHtmlTag(htmlTag)) ||
+            html === null ||
+            json === null ||
+            Object.keys(attrs).some((name) => !isSafeHtmlAttr(name))) {
+            return null;
+        }
+        nodes.push({
+            name: rawNode.name,
+            content: typeof raw.content === 'string' ? raw.content : '',
+            ...(typeof raw.group === 'string' ? { group: raw.group } : {}),
+            ...(Object.keys(attrs).length > 0 ? { attrs } : {}),
+            role: normalizeRole(raw.role),
+            ...(htmlTag == null ? {} : { htmlTag }),
+            ...(html == null ? {} : { html }),
+            ...(json == null ? {} : { json }),
+            isVoid: typeof raw.isVoid === 'boolean' ? raw.isVoid : false,
+            ...(typeof raw.deletableOnBackspace === 'boolean'
+                ? { deletableOnBackspace: raw.deletableOnBackspace }
+                : {}),
+            ...(typeof raw.allowUndeclaredAttrs === 'boolean'
+                ? { allowUndeclaredAttrs: raw.allowUndeclaredAttrs }
+                : {}),
+        });
+    }
+    const nativeNodeNames = new Set(nodes.map((node) => node.name));
+    const projectedNodes = nodes.filter((node) => node.json != null);
+    for (let index = 0; index < projectedNodes.length; index += 1) {
+        const node = projectedNodes[index];
+        const projection = node.json;
+        const legacyHeadingName = legacyHeadingProjectionName(projection);
+        if (nativeNodeNames.has(projection.type) ||
+            atomPolicy_1.RESERVED_WIRE_NODE_TYPES.has(projection.type) ||
+            (legacyHeadingName != null &&
+                legacyHeadingName !== node.name &&
+                nativeNodeNames.has(legacyHeadingName)) ||
+            Object.keys(projection.attrs ?? {}).some((name) => Object.prototype.hasOwnProperty.call(node.attrs ?? {}, name))) {
+            return null;
+        }
+        for (let previousIndex = 0; previousIndex < index; previousIndex += 1) {
+            if (budget != null && !consumeSchemaWork(budget)) {
+                throw schemaBoundaryError(budget.limit, budget.limit + 1);
+            }
+            const previous = projectedNodes[previousIndex];
+            if (previous.json?.type === projection.type &&
+                projectionAttrsOverlap(projection.attrs ?? {}, previous.json.attrs ?? {})) {
+                return null;
+            }
+        }
+    }
+    const marks = [];
+    for (let markIndex = 0; markIndex < schema.marks.length; markIndex += 1) {
+        const rawMark = schema.marks[markIndex];
+        if (rawMark == null || typeof rawMark !== 'object' || typeof rawMark.name !== 'string') {
+            return null;
+        }
+        const raw = rawMark;
+        const htmlTag = typeof raw.htmlTag === 'string' ? raw.htmlTag.toLowerCase() : undefined;
+        const attrs = normalizeAttrs(raw.attrs);
+        if ((htmlTag != null && !schemaDefinition_1.ALLOWED_MARK_HTML_TAGS.has(htmlTag)) ||
+            Object.keys(attrs).some((name) => !isSafeHtmlAttr(name))) {
+            return null;
+        }
+        marks.push({
+            name: rawMark.name,
+            ...(Object.keys(attrs).length > 0 ? { attrs } : {}),
+            ...(typeof raw.excludes === 'string' ? { excludes: raw.excludes } : {}),
+            ...(htmlTag == null ? {} : { htmlTag: htmlTag }),
+            ...(typeof raw.allowUndeclaredAttrs === 'boolean'
+                ? { allowUndeclaredAttrs: raw.allowUndeclaredAttrs }
+                : {}),
+        });
+    }
+    return { nodes, marks };
+}

package/dist/schemaPresets.d.ts

@@ -0,0 +1,68 @@
+import type { DocumentJSON } from './NativeEditorBridge';
+import { type EditorResourceLimits } from './ResourceLimits';
+import { type SchemaDefinition, type SchemaNodeSpec, type NodeSpec, type SchemaSpec } from './schemaDefinition';
+/** Attributes of the built-in image node. */
+export interface ImageNodeAttributes {
+    /** Image source: an `https:` URL, or a `data:` URL when base64 images are allowed. */
+    src: string;
+    alt?: string | null;
+    title?: string | null;
+    /** Intrinsic width in layout units. Null lets the renderer choose. */
+    width?: number | null;
+    /** Intrinsic height in layout units. Null lets the renderer choose. */
+    height?: number | null;
+}
+/** A schema together with the facts derived from it. See {@link resolveDocumentDescriptor}. */
+export interface ResolvedDocumentSchema {
+    /** The schema itself, defaulted to {@link defaultSchema} when none was supplied. */
+    schema: SchemaDefinition;
+    /** Name of the node with `role: 'doc'` — the `type` of a document's root. */
+    documentNodeName: string;
+    /** The smallest document this schema admits. Used by `clearContent()`. */
+    emptyDocument: DocumentJSON;
+}
+export type DocumentDescriptorLimits = Pick<EditorResourceLimits, 'maxSchemaNodes' | 'maxSchemaExpressionBytes' | 'maxDocumentNodes' | 'maxDocumentDepth'>;
+/** Node name the built-in image node is stored under. */
+export declare const IMAGE_NODE_NAME = "image";
+export declare const HEADING_LEVELS: readonly [1, 2, 3, 4, 5, 6];
+/**
+ * The built-in image node spec: a void block node carrying
+ * {@link ImageNodeAttributes}. Add it through {@link withImagesSchema}.
+ *
+ * @param name Node name to declare it under. Defaults to {@link IMAGE_NODE_NAME}.
+ */
+export declare function imageSchemaNodeSpec(): SchemaNodeSpec;
+export declare function imageNodeSpec(name?: string): NodeSpec;
+/**
+ * Return `schema` with the image node added, or `schema` unchanged when it
+ * already declares one. {@link tiptapCompatibleSchema} already includes it.
+ */
+export declare function withImagesSchema(schema: SchemaDefinition): SchemaDefinition;
+/**
+ * Wrap inline or block nodes in a document root, producing a fragment ready
+ * for `insertContentJson`.
+ *
+ * @param descriptor Document node name to wrap in. Defaults to `doc`; pass a
+ * {@link ResolvedDocumentSchema} when the schema names its root differently.
+ */
+export declare function buildDocumentFragmentJson(content: DocumentJSON[], descriptor?: Pick<ResolvedDocumentSchema, 'documentNodeName'>): DocumentJSON;
+/**
+ * Build a document fragment holding one image node, ready for
+ * `insertContentJson`. `RichTextEditorRef.insertImage` does this for
+ * you; use this when assembling a larger insertion by hand.
+ */
+export declare function buildImageFragmentJson(attrs: ImageNodeAttributes, descriptor?: Pick<ResolvedDocumentSchema, 'documentNodeName'>): DocumentJSON;
+/**
+ * Keyed authoring definition for the Tiptap-compatible camelCase schema.
+ */
+export declare const tiptapCompatibleSchemaSpec: SchemaSpec;
+/** Tiptap-compatible serializable schema using camelCase node names. */
+export declare const tiptapCompatibleSchema: SchemaDefinition;
+/** Keyed authoring definition using ProseMirror names, including upstream `codeBlock`. */
+export declare const prosemirrorSchemaSpec: SchemaSpec;
+/** ProseMirror-compatible serializable schema, including upstream `codeBlock`. */
+export declare const prosemirrorSchema: SchemaDefinition;
+/** Keyed authoring definition used when callers do not provide a schema. */
+export declare const defaultSchemaSpec: SchemaSpec;
+/** Schema used when callers do not provide one. */
+export declare const defaultSchema: SchemaDefinition;