@openleaf-editor/core 0.1.0-beta.0

package/dist/keymap.js

@@ -0,0 +1,106 @@
+/**
+ * Keyboard shortcuts.
+ *
+ * Bindings follow whatever convention the largest number of users already have
+ * in their fingers, which usually means Word and Google Docs rather than
+ * anything invented here. Where those disagree, the web convention wins,
+ * because this editor lives in a browser.
+ *
+ * `Mod` resolves to Cmd on macOS and Ctrl elsewhere.
+ *
+ * ## On Tab
+ *
+ * Tab is deliberately NOT bound to list indentation, even though Word does it
+ * and users ask for it. Inside a `contenteditable`, capturing Tab removes the
+ * only way a keyboard user has to leave the editor, which is a WCAG 2.1.2
+ * keyboard-trap failure -- and for the institutional users who most need a free
+ * editor, that is a procurement blocker rather than a rough edge.
+ *
+ * Indentation uses `Mod-[` and `Mod-]` instead, matching Google Docs and
+ * VS Code. If Tab is ever added it must come with a documented escape (Escape
+ * then Tab, or a first-Tab-escapes heuristic) and real screen reader testing.
+ */
+import { baseKeymap, chainCommands, exitCode } from 'prosemirror-commands';
+import { redo, undo } from 'prosemirror-history';
+import { indentListItem, insertHorizontalRule, outdentListItem, setParagraph, splitListItemCommand, toggleBlockquote, toggleBold, toggleBulletList, toggleCodeBlock, toggleHeading, toggleInlineCode, toggleItalic, toggleOrderedList, toggleStrike, toggleUnderline, } from './commands.js';
+/**
+ * The default shortcut table.
+ *
+ * Exported as data rather than as a finished keymap so that an integrator can
+ * remove a binding that collides with their own application, and so the help
+ * dialog and the toolbar tooltips can render the real bindings instead of a
+ * hand-maintained duplicate list that drifts.
+ */
+export const shortcuts = [
+    // Marks. Mod-b/i/u are universal; Mod-Shift-x and Mod-e follow GitHub.
+    { keys: 'Mod-b', command: toggleBold, label: 'Bold' },
+    { keys: 'Mod-i', command: toggleItalic, label: 'Italic' },
+    // Note: Mod-u is a View Source accelerator in some browsers. It has not been
+    // a problem in testing, but if it becomes one the workaround belongs here.
+    { keys: 'Mod-u', command: toggleUnderline, label: 'Underline' },
+    { keys: 'Mod-Shift-x', command: toggleStrike, label: 'Strikethrough' },
+    { keys: 'Mod-e', command: toggleInlineCode, label: 'Inline code' },
+    // Blocks. Mod-Alt-N for headings matches Google Docs.
+    { keys: 'Mod-Alt-0', command: setParagraph, label: 'Paragraph' },
+    ...[1, 2, 3, 4, 5, 6].map((level) => ({
+        keys: `Mod-Alt-${level}`,
+        command: toggleHeading(level),
+        label: `Heading ${level}`,
+    })),
+    { keys: 'Mod-Shift-.', command: toggleBlockquote, label: 'Blockquote' },
+    { keys: 'Mod-Alt-c', command: toggleCodeBlock, label: 'Code block' },
+    { keys: 'Mod-Shift-Enter', command: insertHorizontalRule, label: 'Horizontal rule' },
+    // Lists. Mod-Shift-7/8 matches Word and Google Docs.
+    { keys: 'Mod-Shift-7', command: toggleOrderedList, label: 'Numbered list' },
+    { keys: 'Mod-Shift-8', command: toggleBulletList, label: 'Bulleted list' },
+    { keys: 'Mod-]', command: indentListItem, label: 'Indent list item' },
+    { keys: 'Mod-[', command: outdentListItem, label: 'Outdent list item' },
+    // History.
+    { keys: 'Mod-z', command: undo, label: 'Undo' },
+    { keys: 'Mod-Shift-z', command: redo, label: 'Redo' },
+    { keys: 'Mod-y', command: redo, label: 'Redo' },
+];
+/**
+ * Build the keymap bindings object.
+ *
+ * `Enter` chains: splitting a list item must be tried before ProseMirror's
+ * default paragraph split, or pressing Enter in a list creates a paragraph
+ * instead of the next bullet.
+ */
+export function buildKeymap(custom = {}) {
+    const bindings = {};
+    for (const { keys, command } of shortcuts) {
+        // Later entries chain behind earlier ones so two shortcuts can share a key
+        // and the first that applies wins -- which is how Mod-y and Mod-Shift-z
+        // both mean redo without clobbering each other.
+        const existing = bindings[keys];
+        bindings[keys] = existing ? chainCommands(existing, command) : command;
+    }
+    bindings['Enter'] = chainCommands(splitListItemCommand, baseKeymap['Enter']);
+    bindings['Shift-Enter'] = chainCommands(exitCode, (state, dispatch) => {
+        const br = state.schema.nodes['hard_break'];
+        if (!br)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+        return true;
+    });
+    return { ...bindings, ...custom };
+}
+/** Human-readable shortcut for a label, with the platform's modifier symbol. */
+export function shortcutFor(label, isMac = detectMac()) {
+    const found = shortcuts.find((s) => s.label === label);
+    if (!found)
+        return null;
+    return found.keys
+        .replace(/Mod/g, isMac ? '⌘' : 'Ctrl')
+        .replace(/Alt/g, isMac ? '⌥' : 'Alt')
+        .replace(/Shift/g, isMac ? '⇧' : 'Shift')
+        .replace(/-/g, isMac ? '' : '+');
+}
+function detectMac() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent);
+}
+//# sourceMappingURL=keymap.js.map

package/dist/keymap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keymap.js","sourceRoot":"","sources":["../src/keymap.ts"],"names":[],"mappings":"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"}

package/dist/plugins.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The editor plugin registry.
+ *
+ * A ProseMirror plugin cannot be added to a running editor, so anything that
+ * contributes one has to do it before the view is constructed. This registry is
+ * how an opt-in bundle -- loaded by a second `<script>` tag, after the core
+ * bundle -- gets its plugins into editors that have not been created yet.
+ *
+ * Factories rather than plugin instances: a ProseMirror plugin instance carries
+ * per-editor state and cannot be shared between two editors on the same page.
+ * Calling the factory once per editor is the difference between two working
+ * editors and two editors fighting over one plugin's state.
+ */
+import type { Plugin } from 'prosemirror-state';
+import type { Schema } from 'prosemirror-model';
+export type EditorPluginFactory = (schema: Schema) => Plugin[];
+/** Register plugins to be installed in every editor created from now on. */
+export declare function registerEditorPlugin(factory: EditorPluginFactory): () => void;
+/** Build plugin instances for an editor, reusing cached instances when given. */
+export declare function createRegisteredPlugins(schema: Schema, cache?: Map<EditorPluginFactory, Plugin[]>): Plugin[];
+/**
+ * Notified when a plugin registers.
+ *
+ * An editor already on the page when a deferred bundle finishes loading would
+ * otherwise never receive its plugins, and the author would find table controls
+ * that do nothing.
+ */
+export declare function onEditorPluginsChange(listener: () => void): () => void;
+//# sourceMappingURL=plugins.d.ts.map

package/dist/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,EAAE,CAAA;AAK9D,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,IAAI,CAU7E;AAoBD,iFAAiF;AACjF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,GAAG,CAAC,mBAAmB,EAAE,MAAM,EAAE,CAAC,GACzC,MAAM,EAAE,CA2BV;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKtE"}

package/dist/plugins.js

@@ -0,0 +1,91 @@
+/**
+ * The editor plugin registry.
+ *
+ * A ProseMirror plugin cannot be added to a running editor, so anything that
+ * contributes one has to do it before the view is constructed. This registry is
+ * how an opt-in bundle -- loaded by a second `<script>` tag, after the core
+ * bundle -- gets its plugins into editors that have not been created yet.
+ *
+ * Factories rather than plugin instances: a ProseMirror plugin instance carries
+ * per-editor state and cannot be shared between two editors on the same page.
+ * Calling the factory once per editor is the difference between two working
+ * editors and two editors fighting over one plugin's state.
+ */
+const factories = new Set();
+const listeners = new Set();
+/** Register plugins to be installed in every editor created from now on. */
+export function registerEditorPlugin(factory) {
+    factories.add(factory);
+    notify();
+    return () => {
+        // Notify on removal too. Without it the disposer deleted the factory and
+        // told nobody, so every editor already on the page kept the plugin running
+        // -- a disposer that is observably a no-op in the common case is worse than
+        // none, because callers believe it worked.
+        if (factories.delete(factory))
+            notify();
+    };
+}
+/**
+ * Notify listeners, isolating each one.
+ *
+ * These listeners are editors. On a page with three of them, an exception from
+ * the second must not stop the third from ever seeing the plugin -- and it must
+ * not propagate back out of `registerEditorPlugin` into the calling plugin,
+ * where a broken editor would look like a broken install.
+ */
+function notify() {
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch (error) {
+            console.error('@openleaf-editor/core: an editor failed to apply a plugin change', error);
+        }
+    }
+}
+/** Build plugin instances for an editor, reusing cached instances when given. */
+export function createRegisteredPlugins(schema, cache) {
+    const plugins = [];
+    const seen = new Set();
+    for (const factory of factories) {
+        seen.add(factory);
+        const cached = cache?.get(factory);
+        if (cached) {
+            plugins.push(...cached);
+            continue;
+        }
+        try {
+            const created = factory(schema);
+            cache?.set(factory, created);
+            plugins.push(...created);
+        }
+        catch (error) {
+            // A throwing factory used to take EditorState.create with it, so one bad
+            // script tag produced a blank editor. Contributing nothing is the right
+            // failure: the editor comes up without that plugin.
+            console.error('@openleaf-editor/core: a plugin factory threw; skipping it', error);
+        }
+    }
+    if (cache) {
+        for (const factory of [...cache.keys()]) {
+            if (!seen.has(factory))
+                cache.delete(factory);
+        }
+    }
+    return plugins;
+}
+/**
+ * Notified when a plugin registers.
+ *
+ * An editor already on the page when a deferred bundle finishes loading would
+ * otherwise never receive its plugins, and the author would find table controls
+ * that do nothing.
+ */
+export function onEditorPluginsChange(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+//# sourceMappingURL=plugins.js.map

package/dist/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,MAAM,SAAS,GAAG,IAAI,GAAG,EAAuB,CAAA;AAChD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAc,CAAA;AAEvC,4EAA4E;AAC5E,MAAM,UAAU,oBAAoB,CAAC,OAA4B;IAC/D,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IACtB,MAAM,EAAE,CAAA;IACR,OAAO,GAAG,EAAE;QACV,yEAAyE;QACzE,2EAA2E;QAC3E,4EAA4E;QAC5E,2CAA2C;QAC3C,IAAI,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC;YAAE,MAAM,EAAE,CAAA;IACzC,CAAC,CAAA;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,MAAM;IACb,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,CAAC;YACH,QAAQ,EAAE,CAAA;QACZ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,kEAAkE,EAAE,KAAK,CAAC,CAAA;QAC1F,CAAC;IACH,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,uBAAuB,CACrC,MAAc,EACd,KAA0C;IAE1C,MAAM,OAAO,GAAa,EAAE,CAAA;IAC5B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAA;IAC3C,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QACjB,MAAM,MAAM,GAAG,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;QAClC,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAA;YACvB,SAAQ;QACV,CAAC;QACD,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;YAC/B,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAC5B,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAA;QAC1B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,yEAAyE;YACzE,wEAAwE;YACxE,oDAAoD;YACpD,OAAO,CAAC,KAAK,CAAC,4DAA4D,EAAE,KAAK,CAAC,CAAA;QACpF,CAAC;IACH,CAAC;IACD,IAAI,KAAK,EAAE,CAAC;QACV,KAAK,MAAM,OAAO,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;gBAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;QAC/C,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAoB;IACxD,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IACvB,OAAO,GAAG,EAAE;QACV,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC5B,CAAC,CAAA;AACH,CAAC"}

package/dist/preserve.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The content-preservation layer.
+ *
+ * ProseMirror is schema-strict: anything its schema does not recognise is
+ * silently discarded. TinyMCE is permissive: it round-trips almost
+ * anything. That difference is the single largest risk in replacing
+ * TinyMCE with a ProseMirror-based editor, because the failure mode is
+ * not an error -- it is a customer opening a ten-year-old blog post,
+ * pressing Save, and losing a section of it with no warning.
+ *
+ * This module makes that failure impossible by construction. Unrecognised
+ * markup is captured verbatim into an atom node rather than dropped, and
+ * re-emitted byte-identical on serialization.
+ *
+ * The governing distinction:
+ *
+ *   NORMALIZATION is allowed.  `<div>hi</div>` becoming `<p>hi</p>` is
+ *   fine -- no information is lost, the markup is merely made canonical.
+ *
+ *   INFORMATION LOSS is not.   `<div class="callout">hi</div>` becoming
+ *   `<p>hi</p>` silently destroys the author's intent. The class was
+ *   load-bearing and we had no way to know it wasn't.
+ *
+ * So the rule is not "is this tag known?" but "would unwrapping this
+ * lose information?" A bare structural wrapper unwraps. The moment an
+ * element carries an attribute we cannot represent, it becomes opaque
+ * and is preserved intact.
+ */
+import type { NodeSpec } from 'prosemirror-model';
+/**
+ * True when this element can be unwrapped without losing information.
+ *
+ * Conservative on purpose: ANY attribute makes an element opaque, even a
+ * seemingly harmless one. We would rather preserve a redundant `id` than
+ * guess wrong about a `data-` attribute some integration depends on.
+ * Over-preserving is visible and correctable by the user; under-
+ * preserving is invisible and permanent.
+ */
+export declare function isLosslesslyUnwrappable(el: Element): boolean;
+/** Run `fn` with preserved-node serialization targeting this Document. */
+export declare function withSerializationDocument<T>(doc: Document, fn: () => T): T;
+/** True when this element, or an ancestor, was rendered from preserved markup. */
+export declare function isInsidePreserved(node: Element | null): boolean;
+/**
+ * Block-level preserved content. An atom: the editor can select, move and
+ * delete it, but never edits its interior, so its markup cannot drift.
+ */
+export declare const unknownBlock: NodeSpec;
+/**
+ * Inline preserved content, for unrecognised markup appearing inside a
+ * paragraph -- the `<o:p>` and `<w:sdt>` debris of a Word paste, custom
+ * inline web components, legacy `<font>` runs.
+ */
+export declare const unknownInline: NodeSpec;
+//# sourceMappingURL=preserve.d.ts.map

package/dist/preserve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preserve.d.ts","sourceRoot":"","sources":["../src/preserve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAuGjD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAG5D;AAoBD,0EAA0E;AAC1E,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQ1E;AAwCD,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAK/D;AAeD;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,QA4B1B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,QA4B3B,CAAA"}

package/dist/preserve.js

@@ -0,0 +1,288 @@
+/**
+ * The content-preservation layer.
+ *
+ * ProseMirror is schema-strict: anything its schema does not recognise is
+ * silently discarded. TinyMCE is permissive: it round-trips almost
+ * anything. That difference is the single largest risk in replacing
+ * TinyMCE with a ProseMirror-based editor, because the failure mode is
+ * not an error -- it is a customer opening a ten-year-old blog post,
+ * pressing Save, and losing a section of it with no warning.
+ *
+ * This module makes that failure impossible by construction. Unrecognised
+ * markup is captured verbatim into an atom node rather than dropped, and
+ * re-emitted byte-identical on serialization.
+ *
+ * The governing distinction:
+ *
+ *   NORMALIZATION is allowed.  `<div>hi</div>` becoming `<p>hi</p>` is
+ *   fine -- no information is lost, the markup is merely made canonical.
+ *
+ *   INFORMATION LOSS is not.   `<div class="callout">hi</div>` becoming
+ *   `<p>hi</p>` silently destroys the author's intent. The class was
+ *   load-bearing and we had no way to know it wasn't.
+ *
+ * So the rule is not "is this tag known?" but "would unwrapping this
+ * lose information?" A bare structural wrapper unwraps. The moment an
+ * element carries an attribute we cannot represent, it becomes opaque
+ * and is preserved intact.
+ */
+import { URL_ATTRIBUTES, isEventHandlerAttribute, isSafeUrl } from './url.js';
+/**
+ * Elements that are never preserved, and whose contents are discarded with them.
+ *
+ * This is where the project's two strongest instincts collide. The preservation
+ * layer exists because silently deleting a customer's markup is the failure
+ * OpenLeaf was built to prevent -- but "markup the schema does not recognise"
+ * includes `<script>`.
+ *
+ * Preserving an author's `<div class="callout">` is the product working.
+ * Preserving a `<script>` is a vulnerability with extra steps: the editor would
+ * hand it back on save, the server would store it, and the next reader would
+ * execute it. The content-safety promise is about *authorial content*, and a
+ * script tag is not that.
+ *
+ * `ignore` rather than `skip`: the element AND its contents go. Skipping would
+ * unwrap `<script>alert(1)</script>` into the literal text "alert(1)" appearing
+ * in the document, which is a different kind of wrong.
+ */
+const NEVER_PRESERVE = [
+    'script',
+    'style',
+    'iframe',
+    'frame',
+    'frameset',
+    'object',
+    'embed',
+    'applet',
+    'form',
+    'input',
+    'button',
+    'select',
+    'textarea',
+    'option',
+    'link',
+    'meta',
+    'base',
+    'noscript',
+    'template',
+];
+/** Parse rules that drop dangerous elements before any other rule sees them. */
+const dropRules = NEVER_PRESERVE.map((tag) => ({ tag, ignore: true, priority: 100 }));
+/**
+ * Scrub markup before it is stored for preservation.
+ *
+ * Preserving an element verbatim means preserving its attributes verbatim, and
+ * `<div class="callout" onclick="steal()">` is not something an author needs
+ * kept. Works on a clone so the live parse tree is untouched.
+ */
+function scrub(el) {
+    const clone = el.cloneNode(true);
+    const visit = (node) => {
+        for (const child of Array.from(node.children)) {
+            if (NEVER_PRESERVE.includes(child.nodeName.toLowerCase())) {
+                child.remove();
+                continue;
+            }
+            visit(child);
+        }
+        for (const attr of Array.from(node.attributes)) {
+            if (isEventHandlerAttribute(attr.name)) {
+                node.removeAttribute(attr.name);
+                continue;
+            }
+            if (URL_ATTRIBUTES.has(attr.name.toLowerCase()) && !isSafeUrl(attr.value)) {
+                node.removeAttribute(attr.name);
+            }
+        }
+    };
+    visit(clone);
+    return clone.outerHTML;
+}
+/**
+ * Elements that contribute no meaning of their own -- pure structural
+ * wrappers. Unwrapping one of these loses nothing, PROVIDED it carries no
+ * attributes.
+ *
+ * Deliberately excluded, because they do carry meaning we would lose:
+ *   figure/figcaption (image semantics -- belongs to a real node type)
+ *   center, font       (presentational intent)
+ *   ins, del           (revision semantics)
+ *   details, summary   (interaction semantics)
+ */
+const TRANSPARENT_CONTAINERS = new Set([
+    'div',
+    'section',
+    'article',
+    'main',
+    'aside',
+    'header',
+    'footer',
+    'nav',
+    'span',
+    'hgroup',
+]);
+/**
+ * True when this element can be unwrapped without losing information.
+ *
+ * Conservative on purpose: ANY attribute makes an element opaque, even a
+ * seemingly harmless one. We would rather preserve a redundant `id` than
+ * guess wrong about a `data-` attribute some integration depends on.
+ * Over-preserving is visible and correctable by the user; under-
+ * preserving is invisible and permanent.
+ */
+export function isLosslesslyUnwrappable(el) {
+    if (!TRANSPARENT_CONTAINERS.has(el.nodeName.toLowerCase()))
+        return false;
+    return el.attributes.length === 0;
+}
+/** Rebuild a DOM element from stored markup. `<template>` is used because
+ *  its parsing context permits otherwise-illegal fragments such as a bare
+ *  `<tr>`, which a `<div>` container would silently discard. */
+function elementFromHtml(html, doc) {
+    const tpl = doc.createElement('template');
+    tpl.innerHTML = html;
+    return tpl.content.firstElementChild;
+}
+/**
+ * ProseMirror's `toDOM` does not receive the `document` passed to
+ * `serializeFragment`. Preserved nodes rebuild markup inside `toDOM`, so the
+ * explicit Document has to travel out of band for the duration of one
+ * serialize. Nested calls restore the previous value so a re-entrant serialize
+ * cannot leak a document across documents.
+ */
+let serializationDocument;
+/** Run `fn` with preserved-node serialization targeting this Document. */
+export function withSerializationDocument(doc, fn) {
+    const previous = serializationDocument;
+    serializationDocument = doc;
+    try {
+        return fn();
+    }
+    finally {
+        serializationDocument = previous;
+    }
+}
+function ownerDocument() {
+    if (serializationDocument)
+        return serializationDocument;
+    if (typeof document === 'undefined') {
+        throw new Error('@openleaf-editor/core: no global `document` available. Preserved content ' +
+            'needs a DOM to re-serialize. On the server, pass an explicit ' +
+            'document to parseHtml/serializeHtml.');
+    }
+    return document;
+}
+/**
+ * Rebuild preserved markup, or -- if it somehow will not re-parse -- carry it
+ * out on a data attribute rather than dropping it.
+ *
+ * This fallback should be unreachable, because the stored string came from
+ * `outerHTML` of an element the browser had already parsed. It exists anyway:
+ * emitting something slightly odd is always preferable to destroying a user's
+ * content, and an unreachable branch that preserves data costs nothing.
+ */
+/**
+ * Elements rendered from preserved markup, identified out of band.
+ *
+ * Normalization passes running over the serialized output need to tell "markup
+ * we own" from "markup we promised not to touch". The first attempt marked
+ * preserved output with a real DOM attribute and stripped it afterwards -- which
+ * could not distinguish the attribute it had just added from the same attribute
+ * occurring in somebody's document, so a customer using `data-ol-preserved` had
+ * it silently deleted. Destroying an attribute inside preserved content is the
+ * exact failure the marker existed to prevent.
+ *
+ * A WeakSet cannot collide with content, needs no cleanup pass, and holds its
+ * entries weakly so a serialization's throwaway DOM is still collectable.
+ */
+const preservedElements = new WeakSet();
+/** True when this element, or an ancestor, was rendered from preserved markup. */
+export function isInsidePreserved(node) {
+    for (let current = node; current; current = current.parentElement) {
+        if (preservedElements.has(current))
+            return true;
+    }
+    return false;
+}
+function rebuildOrCarry(html, fallbackTag) {
+    const doc = ownerDocument();
+    const rebuilt = elementFromHtml(html, doc);
+    if (rebuilt) {
+        preservedElements.add(rebuilt);
+        return rebuilt;
+    }
+    const carrier = doc.createElement(fallbackTag);
+    carrier.setAttribute('data-openleaf-unparsable', html);
+    preservedElements.add(carrier);
+    return carrier;
+}
+/**
+ * Block-level preserved content. An atom: the editor can select, move and
+ * delete it, but never edits its interior, so its markup cannot drift.
+ */
+export const unknownBlock = {
+    group: 'block',
+    atom: true,
+    selectable: true,
+    isolating: true,
+    attrs: {
+        html: { default: '' },
+        tag: { default: 'div' },
+    },
+    parseDOM: [
+        ...dropRules,
+        {
+            tag: '*',
+            // Lowest priority: every real rule in the schema gets first refusal.
+            // This only ever fires for markup nothing else claimed.
+            priority: 0,
+            getAttrs(dom) {
+                const el = dom;
+                // Returning false declines the rule, so ProseMirror falls through
+                // to its default behaviour -- unwrap, keep the children editable.
+                if (isLosslesslyUnwrappable(el))
+                    return false;
+                return { html: scrub(el), tag: el.nodeName.toLowerCase() };
+            },
+        },
+    ],
+    toDOM(node) {
+        return rebuildOrCarry(node.attrs['html'], 'div');
+    },
+};
+/**
+ * Inline preserved content, for unrecognised markup appearing inside a
+ * paragraph -- the `<o:p>` and `<w:sdt>` debris of a Word paste, custom
+ * inline web components, legacy `<font>` runs.
+ */
+export const unknownInline = {
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    attrs: {
+        html: { default: '' },
+        tag: { default: 'span' },
+    },
+    parseDOM: [
+        ...dropRules,
+        {
+            tag: '*',
+            // Higher than unknownBlock's catch-all: inline gets first refusal so
+            // the block rule cannot claim inline debris and split the paragraph
+            // that contained it.
+            priority: 1,
+            context: 'paragraph/|heading/',
+            getAttrs(dom) {
+                const el = dom;
+                if (isLosslesslyUnwrappable(el))
+                    return false;
+                return { html: scrub(el), tag: el.nodeName.toLowerCase() };
+            },
+        },
+    ],
+    toDOM(node) {
+        return rebuildOrCarry(node.attrs['html'], 'span');
+    },
+};
+//# sourceMappingURL=preserve.js.map

package/dist/preserve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preserve.js","sourceRoot":"","sources":["../src/preserve.ts"],"names":[],"mappings":"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"}

package/dist/schema.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The OpenLeaf document schema.
+ *
+ * Scope note: table NODES are here, in the base schema, so that every
+ * deployment reads and writes tables faithfully. Table EDITING -- cell
+ * selection, column resizing, the row and column commands and toolbar -- is
+ * the opt-in @openleaf-editor/plugins-table. See tables.ts for why the split falls
+ * there rather than at the package boundary.
+ */
+import { Schema, type MarkSpec, type NodeSpec } from 'prosemirror-model';
+/** The base node specs. Extensions are appended to these. */
+export declare const coreNodes: Record<string, NodeSpec>;
+/** The base mark specs. */
+export declare const coreMarks: Record<string, MarkSpec>;
+/**
+ * The base schema, with no extensions.
+ *
+ * Kept for the many places that only ever need the built-in types. Anything that
+ * must honour plugin-contributed node types uses `createSchema` or reads
+ * `state.schema` instead -- see extensions.ts.
+ */
+export declare const baseSchema: Schema<string, string>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAKxE,6DAA6D;AAC7D,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAyL9C,CAAA;AAED,2BAA2B;AAC3B,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAkE9C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,wBAAqD,CAAA"}