@portone/docx-editor 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,70 @@
 # @portone/docx-editor
 
+## 0.6.0
+
+### Minor Changes
+
+- [#131](https://github.com/portone-io/docx-editor/pull/131) [`5dd468a`](https://github.com/portone-io/docx-editor/commit/5dd468ae14d6210070ab6c8275d16e03b20cf64c) Thanks [@Deea222](https://github.com/Deea222)! - A comment now outlives the text it was written for, and a resolved one stops marking the page.
+  
+  Deleting commented text used to delete the comment and everything said under it. The thread now
+  stays. Trim the highlighted text - type over part of it, backspace through its edge - and the
+  comment follows what is left. Delete all of it and the comment comes back detached: no longer drawn
+  beside the page, since there is nothing to draw it next to, and listed under All comments marked
+  "Original content deleted". Cutting commented text leaves it behind the same way instead of dropping
+  it. Word has no detached state, so such a comment reaches the saved file as an ordinary comment
+  sitting where the deleted text was. Deleting a comment from its own Delete button still deletes it,
+  and undo and redo still take a deletion back and make it again.
+  
+  Resolving a thread now takes its highlight off the text, and reopening puts it back. Clicking a
+  resolved comment's card in All comments selects the text it was written about and scrolls it into
+  view, which `selectComment` now does for every caller.
+  
+  `documentComments` reports a new `anchored` field on every comment, `false` for one that no longer
+  marks a stretch of the document. Its existing fields are unchanged, so a panel of your own keeps
+  working and can read the new field to decide what a click on a card should do.
+
+## 0.5.1
+
+### Patch Changes
+
+- [#125](https://github.com/portone-io/docx-editor/pull/125) [`88ff33a`](https://github.com/portone-io/docx-editor/commit/88ff33abac21cd56d87723af60d95ab597ccff39) Thanks [@Deea222](https://github.com/Deea222)! - Pasting from Word, Google Docs or LibreOffice now keeps tables as tables and Word lists as lists.
+  
+  A table on the clipboard used to arrive as a single paragraph holding the text of every cell run
+  together. It now arrives as a table: one paragraph for each block a cell held, the columns and rows
+  a cell reached across kept, and the same width and lines a table inserted here has.
+  
+  Word writes list items as ordinary paragraphs that name the list they belong to and draw their own
+  bullet or number, so pasting one used to give unnumbered paragraphs each beginning with a stray
+  marker. The items of one Word list now join one list, at the level Word gives them, counted when
+  the marker Word drew counts.
+  
+  A table's caption is kept as the paragraph above it, a table inside a list item is read as a table
+  rather than as the item's own text, and a table too large for the editor to hold is read as one
+  paragraph per row instead of as a single run-on one.
+  
+  A copy wrapped in a single element, which is how Google Docs writes one, no longer has its
+  paragraphs pressed into one.
+
+- [#123](https://github.com/portone-io/docx-editor/pull/123) [`3d6b0a5`](https://github.com/portone-io/docx-editor/commit/3d6b0a58ea9e0a5ca651a5579d5dd0a8b4646ff6) Thanks [@Deea222](https://github.com/Deea222)! - Copied HTML and text now follow one declared outbound shape per node and mark, so what leaves the editor is decided beside the schema rather than filtered out of the page's own drawing afterwards. A copy pasted into another application carries paragraphs, styles, runs, links, images at the size they were drawn, and tables as tables, and none of the document's internals. A comment marker, a bookmark, and the placeholder standing for content the editor could not model now leave nothing behind them, where before they left an element carrying the editor's own name for what stood there.
+  
+  Copied plain text reads as the page does. A table pasted into a spreadsheet keeps one row per row, with everything a cell holds on the one line that cell stands on, and a block the editor only kept no longer opens a blank line where it stood. A kept line break and a kept character, such as a no-break hyphen, travel with the text they stand in, and so does the text a placeholder draws: a field's cached result and the words of a tracked insertion read in a copy as they read on the page.
+
+- [#124](https://github.com/portone-io/docx-editor/pull/124) [`936b2a0`](https://github.com/portone-io/docx-editor/commit/936b2a08d0d26b1a9b77cf39c718bb85b70a834c) Thanks [@Deea222](https://github.com/Deea222)! - Hyperlinks that hold content controls, and nested controls, open as editable text.
+  
+  Only one of the arrangements used to be readable - a control holding a link. A link holding a
+  control, or a control holding a control, brought the inner one in as a small box naming the element
+  it stood for, and the text it held could not be typed in. Any depth and any order of the two is now
+  ordinary text wearing a wrapper each, and goes back out nested as it came. A hyperlink inside a
+  hyperlink is the one arrangement still kept whole, since a link marks the text it covers once.
+  
+  A link made on text inside a control is written inside that control, and a lock put on a stretch
+  that sits wholly inside a link is written inside that link, instead of either wrapper being split
+  around the other. Where a control holds a control, locking shuts the outer one and lifting a lock
+  opens the inner one the selection stands in.
+  
+  Plugins reading the drawn page will find `data-key` and `data-depth` on a control and a link in
+  place of `data-sdt-key` and `data-link-key`.
+
 ## 0.5.0
 
 ### Minor Changes

package/CONTRIBUTING.md

@@ -44,25 +44,33 @@ Run a specialized check when your change affects its area:
 pnpm test:package
 pnpm verify:package
 pnpm test:e2e
+pnpm bench
 ```
 
+A pull request that changes performance-sensitive code attaches its `pnpm bench` output to the description.
+
 [Testing](https://github.com/portone-io/docx-editor/blob/main/docs/testing.md) explains the scope and prerequisites of every check.
+CI runs `pnpm test:package` on every pull request in a separate job; it is not part of the local `pnpm check` command.
 
 A command added to `./commands` or `./table` needs a writer probe in `src/docx/__testing__/writerProbes.ts` with a `check` of its immediate effect, so its export is validated before another command can overwrite it, or an entry in `NOT_A_WRITER` giving the reason it reaches no writer.
 
 ## Changesets
 
-If you changed anything under `src/`, run `pnpm changeset` and commit the file it writes.
+If you changed production code under `src/`, run `pnpm changeset` and commit the file it writes.
 It becomes the CHANGELOG entry, so write it for someone reading release notes rather than the diff.
+Changes limited to tests, fixtures, scripts, or documentation do not need a changeset.
 
-The public API is the exported names and types of the four entry points - `.`, `./core`, `./commands`, and `./table` - together with the parts of the document model that [What a plugin may rely on](https://docx-editor.portone.io/docs/custom-controls#what-a-plugin-may-rely-on) calls stable.
+The public API is the exported names and types of the four entry points - `.`, `./core`, `./commands`, and `./table` - together with the parts of the document model that [What a plugin may rely on](https://docx-editor.portone.io/docs/editor-api/plugins-and-presets#what-a-plugin-may-rely-on) calls stable.
 An attr that page calls internal is not part of it, and neither is anything under `src/` that no entry point reaches.
 
 Choose `patch` unless the change adds to that surface, takes something out of it, or changes what a part of it means.
 Those are `minor` while the package is below 1.0.
+A diff to `src/schema/attrRoles.ts` is where to check this: a change to a stable document-model attr is `minor` even when the declaration reports do not change.
 A declaration added, removed, or rewritten in `etc/*.api.md` after running `pnpm api:update` is what that looks like; a line that only gains or loses an `(undocumented)` marker is not.
 Commit the regenerated report in the same commit as the changeset.
 
+The changesets that have landed become a release the way [Releasing](https://github.com/portone-io/docx-editor/blob/main/docs/releasing.md) describes.
+
 By contributing, you agree that your contribution is licensed under the Apache License 2.0 used by this project.
 
 ## Commit messages

package/README.md

@@ -47,7 +47,7 @@ export function Editor({
 - Preserves document structures and package parts across edits, and records who wrote each comment.
 - Reads document styles, theme fonts, page layout, and CJK font information for display.
 
-See [Feature support](https://docx-editor.portone.io/docs/features) for the support matrix. Build [custom controls](https://docx-editor.portone.io/docs/custom-controls) or use [programmatic DOCX import and export](https://docx-editor.portone.io/docs/core).
+See [Feature support](https://docx-editor.portone.io/docs/features) for the support matrix. Build controls of your own with the [Editor API](https://docx-editor.portone.io/docs/editor-api) or use [programmatic DOCX import and export](https://docx-editor.portone.io/docs/core).
 
 The full [documentation](https://docx-editor.portone.io/docs) lives on the documentation site.
 

package/dist/DocxEditor.js

@@ -31,7 +31,7 @@ import { usePageLayout } from "./page/usePageLayout.js";
 import { editingProtection, protectionOf } from "./schema/protectionState.js";
 import { storyNodeOf } from "./schema/stories.js";
 import { editorClassNames } from "./styles/classNames.js";
-import { CommentsPanel } from "./ui/CommentsPanel.js";
+import { CommentsPanel, shownBesideThePage } from "./ui/CommentsPanel.js";
 import { LinkCard } from "./ui/LinkCard.js";
 import { LinkPanel } from "./ui/LinkPanel.js";
 import { NotesPanel } from "./ui/NotesPanel.js";
@@ -280,9 +280,9 @@ function DocxEditorSurface({
   const tableAnchor = live && !textAnchor ? tableMenuAnchor(live.state) : null;
   const linkAtCursor = live && !live.view.composing && !isLinkPanelOpen(live.state) ? activeLinkSpan(live.state) : null;
   const comments = live?.state === void 0 ? [] : commentProjection.read(live.state).comments;
-  const hasUnresolvedComments = comments.some((comment) => !comment.resolved);
+  const hasRailComments = comments.some(shownBesideThePage);
   const composerOpen = live !== null && isCommentComposerOpen(live.state);
-  const showComments = live !== null && (commentsOpen || composerOpen || hasUnresolvedComments);
+  const showComments = live !== null && (commentsOpen || composerOpen || hasRailComments);
   const commentsPanel = live && showComments && /* @__PURE__ */ jsx(
     CommentsPanel,
     {

package/dist/docx/formatting/styles.d.ts

@@ -75,8 +75,6 @@ export interface ParagraphStyleOption {
  * `defaultParagraphStyleIdOf` reads them by.
  */
 export declare function readParagraphStyles(styles: Document): ParagraphStyleOption[];
-/** The style name the paragraph formatting XML points at. null if it points at none */
-export declare function styleIdOf(pPr: unknown): string | null;
 /**
  * The values the style a paragraph wears lays down.
  *

package/dist/docx/formatting/styles.js

@@ -5,7 +5,7 @@ import {
   toRunFormat,
   toTableFormat
 } from "../../model/format.js";
-import { parsePropsXml } from "../../ooxml/props.js";
+import { styleIdOf } from "../../ooxml/props.js";
 import { ST_OnOff } from "../../ooxml/simpleTypes.js";
 import { childValue, isOn, wAttr } from "../../ooxml/units.js";
 import { childByLocalName, elementChildren } from "../../ooxml/xml.js";
@@ -201,18 +201,6 @@ function readParagraphStyles(styles) {
   }
   return options;
 }
-var styleIdsByPPr = /* @__PURE__ */ new Map();
-var STYLE_ID_CACHE_LIMIT = 2e3;
-function styleIdOf(pPr) {
-  if (typeof pPr !== "string" || !pPr.includes("pStyle")) return null;
-  const known = styleIdsByPPr.get(pPr);
-  if (known !== void 0) return known;
-  const el = parsePropsXml(pPr);
-  const id = el ? childValue(el, "pStyle") : null;
-  if (styleIdsByPPr.size >= STYLE_ID_CACHE_LIMIT) styleIdsByPPr.clear();
-  styleIdsByPPr.set(pPr, id);
-  return id;
-}
 function paragraphStyleFormat(pPr, styles, defaultStyleId = null) {
   const id = styleIdOf(pPr) ?? defaultStyleId;
   return id === null ? void 0 : styles.get(id);
@@ -241,6 +229,5 @@ export {
   numberingStyleLinks,
   paragraphStyleFormat,
   readParagraphStyles,
-  readStyles,
-  styleIdOf
+  readStyles
 };

package/dist/docx/identities.js

@@ -4,8 +4,9 @@ import { DocxExportError } from "../ooxml/errors.js";
 import { qualify } from "../ooxml/names.js";
 import { parseAttrs } from "../ooxml/tagScan.js";
 import { docxSchema } from "../schema/index.js";
+import { wrappersOf } from "../schema/wrappers.js";
 import { withoutParagraphIds } from "./cloning.js";
-import { copiedControlPrefix, newControlId } from "./sdt.js";
+import { wrapperKindOf } from "./wrappers.js";
 var sourceBlockRule = {
   name: "sourceBlock",
   visit(block, written) {
@@ -51,21 +52,16 @@ var paragraphIdRule = {
     );
   }
 };
-function sdtMarkOf(node) {
-  return node.marks.find((mark) => mark.type === docxSchema.marks.sdt) ?? null;
+function sdtMarksOf(node) {
+  return wrappersOf(node, docxSchema.marks.sdt);
 }
 function controlName(mark) {
-  const key = mark.attrs.sdtKey;
+  const key = mark.attrs.key;
   const prefix = mark.attrs.sdtPrefix;
   return `${typeof key === "number" ? key : 0} ${typeof prefix === "string" ? prefix : ""}`;
 }
 function copiedMark(mark) {
-  const prefix = mark.attrs.sdtPrefix;
-  if (typeof prefix !== "string") return mark;
-  return mark.type.create({
-    ...mark.attrs,
-    sdtPrefix: copiedControlPrefix(prefix, newControlId())
-  });
+  return wrapperKindOf(mark).copy?.(mark) ?? mark;
 }
 function claim(mark, written) {
   const name = controlName(mark);
@@ -75,25 +71,20 @@ function claim(mark, written) {
 }
 function rewriteParagraph(paragraph, written) {
   const inline = [];
-  let running = null;
+  let running = [];
   let renamed = false;
   paragraph.forEach((child) => {
-    const mark = sdtMarkOf(child);
-    if (!mark) {
-      running = null;
-      inline.push(child);
-      return;
-    }
-    const control = running?.mark.eq(mark) ? running : claim(mark, written);
-    running = control;
-    if (!control.copy) {
-      inline.push(child);
-      return;
-    }
-    renamed = true;
-    inline.push(
-      child.mark(control.copy.addToSet(mark.removeFromSet(child.marks)))
+    const controls = sdtMarksOf(child).map(
+      (mark) => running.find((control) => control.mark.eq(mark)) ?? claim(mark, written)
     );
+    running = controls;
+    let marks = child.marks;
+    for (const control of controls) {
+      if (!control.copy) continue;
+      renamed = true;
+      marks = control.copy.addToSet(control.mark.removeFromSet(marks));
+    }
+    inline.push(marks === child.marks ? child : child.mark(marks));
   });
   return renamed ? paragraph.copy(Fragment.fromArray(inline)) : paragraph;
 }

package/dist/docx/importParagraph.d.ts

@@ -5,8 +5,9 @@
  *
  * A `w:sdt` content control and a `w:hyperlink` standing inside the paragraph are both unwrapped, so
  * the text they hold stays editable, and the wrapper each came in rides along on a mark to go back
- * out around the same text. A control may hold a link; a link holding a control is a nesting the
- * marks cannot record in that order, and that control stays whole as one preserved fragment.
+ * out around the same text. Either may hold the other and a control may hold a control: the nesting
+ * is read as the file wrote it and recorded on the marks (`docx/wrappers`). A link inside a link is
+ * the one arrangement no mark can record, and the inner one stays whole as it always has.
  *
  * Nothing here demotes a paragraph. What the editor has no model for - a field character, a
  * tracked insertion, a symbol, a drawing nobody could read - is kept where it stood, inside its
@@ -37,8 +38,8 @@ export declare const NO_IMPORT_SOURCES: ImportSources;
 /**
  * Moves a paragraph into an editable node.
  *
- * Every paragraph opens editable. A child the reader has no model for, and a control or a link
- * whose shape it could not put back together, is kept whole where it stood instead of standing
- * the whole paragraph down.
+ * Every paragraph opens editable. A child the reader has no model for, and a wrapper whose shape
+ * it could not put back together, is kept whole where it stood instead of standing the whole
+ * paragraph down.
  */
 export declare function buildParagraph(el: Element, srcId: string | null, sources?: ImportSources): PMNode;

package/dist/docx/importParagraph.js

@@ -12,10 +12,7 @@ import { docxSchema } from "../schema/index.js";
 import { commentParaId, importedCommentReplies } from "./comments/model.js";
 import { NO_COMMENTS } from "./comments/reading.js";
 import { readParagraphFormat, readRunFormat } from "./formatting.js";
-import {
-  NO_LINK_TARGETS,
-  readHyperlinkWrapper
-} from "./hyperlink.js";
+import { NO_LINK_TARGETS } from "./hyperlink.js";
 import { policyFor } from "./importPolicy.js";
 import {
   buildPreservedInline,
@@ -24,8 +21,8 @@ import {
 } from "./importPreserved.js";
 import { NO_IMAGES } from "./media.js";
 import { NO_NOTES, noteById } from "./notes.js";
-import { readSdtWrapper } from "./sdt.js";
 import { NO_THEME_FONTS } from "./theme.js";
+import { wrapperFits, wrapperKindFor } from "./wrappers.js";
 function runMark(run, themeFonts) {
   const rPr = childByLocalName(run, "rPr");
   return docxSchema.marks.run.create({
@@ -166,13 +163,6 @@ function buildRunNodes(run, images, themeFonts, comments, notes, noteLabel, wrap
   }
   return nodes;
 }
-var controlCounts = /* @__PURE__ */ new WeakMap();
-var linkCounts = /* @__PURE__ */ new WeakMap();
-function nextKey(counts, el) {
-  const key = counts.get(el.ownerDocument) ?? 0;
-  counts.set(el.ownerDocument, key + 1);
-  return key;
-}
 function annotationId(el) {
   return Array.from(el.attributes).find((attribute) => attribute.localName === "id")?.value ?? null;
 }
@@ -190,7 +180,7 @@ var NO_IMPORT_SOURCES = {
   notes: NO_NOTES,
   noteLabel: () => "?"
 };
-function buildModelledWrapperChild(child, sources, wrappers, linkAllowed) {
+function buildModelledInline(child, sources, depth, wrappers) {
   if (child.localName === "r") {
     return buildRunNodes(
       child,
@@ -202,23 +192,25 @@ function buildModelledWrapperChild(child, sources, wrappers, linkAllowed) {
       wrappers
     );
   }
-  if (child.localName === "hyperlink") {
-    return linkAllowed ? buildHyperlinkNodes(child, sources, wrappers) : null;
+  const kind = wrapperKindFor(child);
+  if (kind) {
+    if (!wrapperFits(kind, wrappers)) return null;
+    const reading = kind.read(child, depth, sources);
+    if (!reading) return null;
+    return buildContent(reading.content, sources, depth + 1, [
+      ...wrappers,
+      reading.mark
+    ]);
   }
   const commentMarker = commentRangeNode(child, wrappers);
   return commentMarker === null ? null : [commentMarker];
 }
-function buildWrappedNodes(content, sources, wrappers, linkAllowed) {
+function buildContent(content, sources, depth, wrappers) {
   const nodes = [];
   for (const child of elementChildren(content)) {
     const policy = policyFor(child, "wrapper");
     if (policy.tier === "model") {
-      const built = buildModelledWrapperChild(
-        child,
-        sources,
-        wrappers,
-        linkAllowed
-      );
+      const built = buildModelledInline(child, sources, depth, wrappers);
       if (built !== null) {
         nodes.push(...built);
         continue;
@@ -231,45 +223,6 @@ function buildWrappedNodes(content, sources, wrappers, linkAllowed) {
   if (nodes.length === 0) return null;
   return nodes;
 }
-function buildHyperlinkNodes(el, sources, wrappers) {
-  const wrapper = readHyperlinkWrapper(el);
-  if (!wrapper) return null;
-  const mark = docxSchema.marks.link.create({
-    linkPrefix: wrapper.prefix,
-    href: wrapper.relId === null ? null : sources.links.get(wrapper.relId) ?? null,
-    linkKey: nextKey(linkCounts, el)
-  });
-  return buildWrappedNodes(el, sources, [...wrappers, mark], false);
-}
-function buildSdtNodes(el, sources) {
-  const wrapper = readSdtWrapper(el);
-  if (!wrapper) return null;
-  const mark = docxSchema.marks.sdt.create({
-    sdtPrefix: wrapper.prefix,
-    sdtKey: nextKey(controlCounts, el),
-    contentsLocked: wrapper.contentsLocked,
-    deletionLocked: wrapper.deletionLocked
-  });
-  return buildWrappedNodes(wrapper.content, sources, [mark], true);
-}
-function buildModelledParagraphChild(child, sources) {
-  if (child.localName === "r") {
-    return buildRunNodes(
-      child,
-      sources.images,
-      sources.themeFonts,
-      sources.comments,
-      sources.notes,
-      sources.noteLabel
-    );
-  }
-  if (child.localName === "sdt") return buildSdtNodes(child, sources);
-  if (child.localName === "hyperlink") {
-    return buildHyperlinkNodes(child, sources, []);
-  }
-  const commentMarker = commentRangeNode(child);
-  return commentMarker === null ? null : [commentMarker];
-}
 function buildParagraph(el, srcId, sources = NO_IMPORT_SOURCES) {
   const inline = [];
   let pPrElement = null;
@@ -280,7 +233,7 @@ function buildParagraph(el, srcId, sources = NO_IMPORT_SOURCES) {
         pPrElement = child;
         continue;
       }
-      const built = buildModelledParagraphChild(child, sources);
+      const built = buildModelledInline(child, sources, 0, []);
       if (built !== null) {
         inline.push(...built);
         continue;

package/dist/docx/importPolicy.js

@@ -5,6 +5,7 @@ import {
   PERMISSION_MARKERS,
   RANGE_MARKERS
 } from "../ooxml/rangeMarkers.js";
+import { WRAPPER_KINDS } from "./wrappers.js";
 var MODEL = { tier: "model" };
 var HIDDEN_MARKER = {
   tier: "marker",
@@ -87,20 +88,24 @@ var PARAGRAPH_CHILDREN = [
   [REVISION_CONTAINERS, INLINE_CHIP],
   [["fldSimple", "smartTag", "customXml", "dir", "bdo", "subDoc"], INLINE_CHIP]
 ];
+var WRAPPER_ELEMENTS = WRAPPER_KINDS.map(
+  (kind) => kind.element
+);
 var PARAGRAPH_LEVEL = new Map([
   ...rules([
-    [["pPr", "r", "hyperlink", "sdt"], MODEL],
+    [["pPr", "r"], MODEL],
     [COMMENT_RANGE_MARKERS, MODEL],
-    ...PARAGRAPH_CHILDREN
+    ...PARAGRAPH_CHILDREN,
+    [WRAPPER_ELEMENTS, MODEL]
   ]),
   ...MATH.map((name) => [name, INLINE_CHIP])
 ]);
 var WRAPPER_LEVEL = new Map([
   ...rules([
-    [["r", "hyperlink"], MODEL],
+    [["r"], MODEL],
     [COMMENT_RANGE_MARKERS, MODEL],
-    [["sdt"], INLINE_CHIP],
-    ...PARAGRAPH_CHILDREN
+    ...PARAGRAPH_CHILDREN,
+    [WRAPPER_ELEMENTS, MODEL]
   ]),
   ...MATH.map((name) => [name, INLINE_CHIP])
 ]);

package/dist/docx/serializeParagraph.d.ts

@@ -7,10 +7,11 @@
  * a piece of that run, and one kept beside the runs is written between them, which is what the
  * two content models admit.
  *
- * The inlines are grouped three times over: neighbours that share their formatting become one run,
- * the runs that share a hyperlink (`w:hyperlink`) go back inside it, and the links and runs that
- * share a content control (`w:sdt`) go back inside the wrapper that mark carries. The control is
- * the outer of the two wrappers, which is the nesting the mark order records (`schema`).
+ * The inlines are grouped from the outside in: neighbours sharing the outermost wrapper each stands
+ * inside go back into it, that grouping is made again one wrapper deeper, and at the bottom the
+ * neighbours that share their formatting become one run. `schema/wrappers` says which wrapper is
+ * which depth, and `docx/wrappers` says what each of them opens and closes as, so a wrapper of a
+ * new kind is written here without this file knowing anything about it.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type ExportRefs } from "./exportRefs";

package/dist/docx/serializeParagraph.js

@@ -9,8 +9,9 @@ import {
 } from "../ooxml/image.js";
 import { wName } from "../ooxml/names.js";
 import { escapeXml } from "../ooxml/xml.js";
+import { wrapperMarks } from "../schema/wrappers.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
-import { relIdIn, withRelId } from "./hyperlink.js";
+import { wrapperKindOf } from "./wrappers.js";
 function sameMark(a, b) {
   if (a === null || b === null) return a === b;
   return a.eq(b);
@@ -141,76 +142,39 @@ function addInline(parts, child, images) {
     parts.push({ kind: "run", mark, pieces: [piece] });
   }
 }
-function splitParagraphGroups(paragraph, refs) {
-  const groups = [];
-  paragraph.forEach((child) => {
-    const sdt = markOf(child, "sdt");
-    const link = markOf(child, "link");
-    let group = groups.at(-1);
-    if (!group || !sameMark(group.sdt, sdt)) {
-      group = { sdt, links: [] };
-      groups.push(group);
-    }
-    let inLink = group.links.at(-1);
-    if (!inLink || !sameMark(inLink.link, link)) {
-      inLink = { link, parts: [] };
-      group.links.push(inLink);
-    }
-    addInline(inLink.parts, child, refs.images);
-  });
-  return groups;
-}
 function renderParagraphPart(part) {
   if (part.kind === "raw") return part.xml;
   const open = openTagXml(wName("r"), rawAttrsOf(part.mark?.attrs.rAttrs));
   const rPr = part.mark?.attrs.rPr;
   return open + (typeof rPr === "string" ? rPr : "") + part.pieces.join("") + "</w:r>";
 }
-function openLinkTag(mark, links) {
-  const prefix = mark.attrs.linkPrefix;
-  const original = typeof prefix === "string" ? prefix : null;
-  const href = mark.attrs.href;
-  if (typeof href !== "string") {
-    if (original !== null) return original;
-    throw new DocxExportError(
-      "lost-original",
-      "a hyperlink carries neither an address nor the opening XML it goes back out as"
-    );
-  }
-  const relId = links.relIdOf(
-    href,
-    original === null ? null : relIdIn(original)
-  );
-  if (relId === void 0) {
-    if (original !== null) return original;
-    throw new DocxExportError(
-      "unsupported-content",
-      "an inserted hyperlink has no relationship to point at; export it through exportDocx"
-    );
+function groupsAtDepth(children, depth) {
+  const groups = [];
+  for (const child of children) {
+    const mark = wrapperMarks(child)[depth] ?? null;
+    const last = groups.at(-1);
+    if (last && sameMark(last.mark, mark)) last.children.push(child);
+    else groups.push({ mark, children: [child] });
   }
-  return withRelId(original ?? "<w:hyperlink>", relId);
+  return groups;
 }
-function renderLinkGroup(group, links) {
-  const body = group.parts.map(renderParagraphPart).join("");
-  if (!group.link) return body;
-  return `${openLinkTag(group.link, links)}${body}</w:hyperlink>`;
+function renderParts(children, images) {
+  const parts = [];
+  for (const child of children) addInline(parts, child, images);
+  return parts.map(renderParagraphPart).join("");
 }
-function renderParagraphGroup(group, refs) {
-  const body = group.links.map((inLink) => renderLinkGroup(inLink, refs.links)).join("");
-  if (!group.sdt) return body;
-  const prefix = group.sdt.attrs.sdtPrefix;
-  if (typeof prefix !== "string") {
-    throw new DocxExportError(
-      "lost-original",
-      "a content control has lost the opening XML it goes back out as"
-    );
-  }
-  return `${prefix}<w:sdtContent>${body}</w:sdtContent></w:sdt>`;
+function renderWrapped(children, depth, refs) {
+  return groupsAtDepth(children, depth).map((group) => {
+    if (group.mark === null) return renderParts(group.children, refs.images);
+    const kind = wrapperKindOf(group.mark);
+    const body = renderWrapped(group.children, depth + 1, refs);
+    return kind.open(group.mark, refs) + body + kind.close(group.mark);
+  }).join("");
 }
 function serializeParagraph(node, refs = NO_EXPORT_REFS) {
   const open = openTagXml(wName("p"), rawAttrsOf(node.attrs.pAttrs));
   const pPr = node.attrs.pPr;
-  const body = splitParagraphGroups(node, refs).map((group) => renderParagraphGroup(group, refs)).join("");
+  const body = renderWrapped(node.children, 0, refs);
   return open + (typeof pPr === "string" ? pPr : "") + body + "</w:p>";
 }
 export {

package/dist/docx/tableTemplate.d.ts

@@ -8,8 +8,24 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type PageGeometry } from "./pageGeometry";
+import { type GridRect } from "./tableFormatting";
+/**
+ * The limit on how many rows and cells one table can hold.
+ * The toolbar grid lets you pick from something smaller (6x6); this only blocks absurd values.
+ */
+export declare const MAX_TABLE_SIDE = 50;
 /** Whether the value can be used as a row count or a cell count */
 export declare function isTableSide(value: number): boolean;
+/**
+ * One cell of a table being built: the block of the grid it covers, and the blocks it holds.
+ *
+ * A cell reaching across columns or down rows exists once, as the cell it starts at, which is how
+ * the model holds a merge and what `serializeTable` writes `w:gridSpan` and `w:vMerge` from.
+ */
+export interface TableCellPlan {
+    rect: GridRect;
+    content?: readonly PMNode[];
+}
 /**
  * A single table made up of nothing but empty cells.
  *
@@ -20,3 +36,12 @@ export declare function isTableSide(value: number): boolean;
  * The row and cell counts must be values that have passed through `isTableSide`.
  */
 export declare function createTableNode(rows: number, cols: number, geometry?: PageGeometry): PMNode;
+/**
+ * The same table, laid out and filled by the caller: the shape a table read off the clipboard
+ * takes, where the cells are neither all one wide nor all empty.
+ *
+ * Everything the table itself wears is the same as a newly inserted one's, so a pasted table is
+ * drawn and written exactly like a table the toolbar put there. The grid the cells are measured
+ * and dressed against is the one they cover between them, row by row.
+ */
+export declare function createTableNodeFrom(plan: readonly (readonly TableCellPlan[])[], geometry?: PageGeometry): PMNode;