@portone/docx-editor 0.3.0 → 0.5.0

package/dist/editor/plugins/numberingDecorations.js

@@ -1,7 +1,9 @@
 // src/editor/plugins/numberingDecorations.ts
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { toParagraphFormat } from "../../model/format.js";
+import {
+  toParagraphFormat
+} from "../../model/format.js";
 import { computeMarkers } from "../../numbering/markers.js";
 import { editorAttributes, editorCssVariables } from "../../styles/classNames.js";
 import { documentOf } from "../editorDocument.js";
@@ -45,13 +47,52 @@ function paragraphMarkers(doc, numbering) {
         from: spot.pos,
         to: spot.pos + spot.nodeSize,
         text: marker.text,
+        suffix: marker.suffix,
+        align: marker.align,
+        run: marker.run,
         ...markerPlacement(spot.format, marker.indent)
       }
     ];
   });
 }
+function markerSpacing(marker) {
+  if (marker.suffix === "tab") {
+    return [`${editorCssVariables.markerWidth}:${marker.widthPt}pt`];
+  }
+  return [
+    `${editorCssVariables.markerWidth}:0`,
+    `${editorCssVariables.markerGap}:0`
+  ];
+}
+function markerFormat(run) {
+  if (!run) return [];
+  const css = [];
+  if (run.bold !== void 0) {
+    css.push(
+      `${editorCssVariables.markerFontWeight}:${run.bold ? "bold" : "normal"}`
+    );
+  }
+  if (run.italic !== void 0) {
+    css.push(
+      `${editorCssVariables.markerFontStyle}:${run.italic ? "italic" : "normal"}`
+    );
+  }
+  if (run.color !== void 0) {
+    css.push(`${editorCssVariables.markerColor}:${run.color}`);
+  }
+  if (run.fontSizePt !== void 0) {
+    css.push(`${editorCssVariables.markerFontSize}:${run.fontSizePt}pt`);
+  }
+  if (run.fontFamily !== void 0) {
+    css.push(`${editorCssVariables.markerFontFamily}:${run.fontFamily}`);
+  }
+  return css;
+}
 function markerStyle(marker) {
-  const css = [`${editorCssVariables.markerWidth}:${marker.widthPt}pt`];
+  const css = [...markerSpacing(marker), ...markerFormat(marker.run)];
+  if (marker.align !== "left") {
+    css.push(`${editorCssVariables.markerAlign}:${marker.align}`);
+  }
   if (marker.indentStartPt !== null) {
     css.push(`margin-inline-start:${marker.indentStartPt}pt`);
   }

package/dist/editor/plugins/panelState.d.ts

@@ -0,0 +1,67 @@
+/**
+ * One convention for every panel the editor opens over a spot in the document: a link panel, a
+ * right click menu, the comment composer.
+ *
+ * Each of them holds the same thing - where it stands, or nothing when it is shut - and answers the
+ * same three questions: open it here, close it, where does it stand. What differs between them is
+ * what "here" is and what an edit or a change of protection does to a panel already open, and those
+ * are the options below rather than four copies of a plugin.
+ *
+ * The anchor is whatever the panel is about: a point on the screen for a menu, a stretch of the
+ * document for the composer. It is read back out of the state as it was put in, so a panel that
+ * needs nothing but "open" carries an anchor that says just that.
+ *
+ * A panel that reads other plugins in `canOpen` or `closeWhen` must be registered after them:
+ * the state a plugin is handed while the transaction is being applied holds the fields of the
+ * plugins ahead of it and nothing of the ones behind it.
+ */
+import { type Command, type EditorState, Plugin, type PluginSpec, type Transaction } from "prosemirror-state";
+/**
+ * What a document change does to an open panel: shut it, or move the anchor along with the change.
+ * Answering null from the mapping shuts it, which is what a stretch the edit swallowed comes to.
+ */
+export type PanelDocChange<Anchor> = "close" | ((anchor: Anchor, tr: Transaction, state: EditorState) => Anchor | null);
+export interface PanelOptions<Anchor> {
+    /** The plugin key's name, which is what a state debugger and a duplicate registration report */
+    name: string;
+    /**
+     * Whether this is an anchor of this panel's. The opening goes through the transaction metadata,
+     * which anything may write, so what is read back is judged rather than trusted
+     */
+    isAnchor(value: unknown): value is Anchor;
+    onDocChange: PanelDocChange<Anchor>;
+    /** Whether the panel may open here. `open` reports false where it says no */
+    canOpen?(state: EditorState, anchor: Anchor): boolean;
+    /**
+     * Whether the panel must shut where the state now stands, asked after every transaction rather
+     * than after an edit alone: a protection switch changes no text (`./documentProtection`), so
+     * `onDocChange` never sees it, and a panel that only a commenter is offered has to go with it.
+     */
+    closeWhen?(state: EditorState, anchor: Anchor): boolean;
+    /**
+     * The view props the panel needs of its own, which is how a panel opened by a DOM event - a
+     * right click - stays one plugin. What that handler does with the event is the panel's business;
+     * all this factory asks is that the opening go through `opening` so the state stays this one.
+     */
+    props?: PluginSpec<Anchor | null>["props"];
+}
+export interface PanelPlugin<Anchor> {
+    plugin: Plugin<Anchor | null>;
+    /**
+     * Opens the panel over this anchor, or moves an open one there. False where `canOpen` says the
+     * panel has nothing to do here, so that a control drawn from it is drawn dead and a key bound to
+     * it is a key this editor did not take.
+     */
+    open(anchor: Anchor): Command;
+    /**
+     * The same opening recorded on a transaction already being built, for an opener that moves the
+     * selection in the same step. `canOpen` is not asked here: an opener holding the event that
+     * asked - a right click landing where the menu belongs - has decided that already.
+     */
+    opening(tr: Transaction, anchor: Anchor): Transaction;
+    /** Closes it. False where it stands closed already, so a key press falls through to what is behind it */
+    close: Command;
+    /** Where the panel stands. Null when it is shut, and for a state built without the plugin */
+    anchor(state: EditorState): Anchor | null;
+}
+export declare function panelPlugin<Anchor>({ name, isAnchor, onDocChange, canOpen, closeWhen, props, }: PanelOptions<Anchor>): PanelPlugin<Anchor>;

package/dist/editor/plugins/panelState.js

@@ -0,0 +1,54 @@
+// src/editor/plugins/panelState.ts
+import {
+  Plugin,
+  PluginKey
+} from "prosemirror-state";
+var CLOSE = /* @__PURE__ */ Symbol("panelClose");
+function panelPlugin({
+  name,
+  isAnchor,
+  onDocChange,
+  canOpen,
+  closeWhen,
+  props
+}) {
+  const key = new PluginKey(name);
+  const anchor = (state) => key.getState(state) ?? null;
+  const moved = (tr, held, next) => {
+    const meta = tr.getMeta(key);
+    if (meta === CLOSE) return null;
+    if (isAnchor(meta)) return meta;
+    if (held === null || !tr.docChanged) return held;
+    return onDocChange === "close" ? null : onDocChange(held, tr, next);
+  };
+  const opening = (tr, over) => tr.setMeta(key, over);
+  return {
+    plugin: new Plugin({
+      key,
+      state: {
+        init: () => null,
+        apply: (tr, held, _before, next) => {
+          const standing = moved(tr, held, next);
+          if (standing === null) return null;
+          return closeWhen?.(next, standing) ? null : standing;
+        }
+      },
+      props
+    }),
+    open: (over) => (state, dispatch) => {
+      if (canOpen && !canOpen(state, over)) return false;
+      dispatch?.(opening(state.tr, over));
+      return true;
+    },
+    opening,
+    close: (state, dispatch) => {
+      if (anchor(state) === null) return false;
+      dispatch?.(state.tr.setMeta(key, CLOSE));
+      return true;
+    },
+    anchor
+  };
+}
+export {
+  panelPlugin
+};

package/dist/editor/plugins/paragraphDisplay.js

@@ -6,6 +6,7 @@ import {
 } from "../../docx/formatting.js";
 import { docxSchema } from "../../schema/index.js";
 import { paragraphPPr } from "../paragraphEdits.js";
+import { paragraphPlacementAt } from "../paragraphPlacement.js";
 function carriesNothing(node) {
   return node.attrs.format === null && node.attrs.styleRun === null;
 }
@@ -18,12 +19,17 @@ function holdsComposition(node, pos, composing) {
 var paragraphDisplay = {
   name: "paragraph",
   nodeTypes: ["paragraph"],
-  derive(node, pos, _doc, context, previous) {
-    if (stands(node, previous) || holdsComposition(node, pos, context.composingAt)) {
+  derive(node, pos, doc, context, previous) {
+    const placement = paragraphPlacementAt(doc, pos);
+    if (placement === null && stands(node, previous) || holdsComposition(node, pos, context.composingAt)) {
       return [];
     }
     const formatting = context.document.formatting;
-    const paragraph = resolveParagraph(paragraphPPr(node), formatting);
+    const paragraph = resolveParagraph(
+      paragraphPPr(node),
+      formatting,
+      placement
+    );
     const derived = [
       { pos, attrs: paragraphAttrsOf(paragraph) }
     ];

package/dist/editor/plugins/tableContextMenu.d.ts

@@ -8,7 +8,7 @@
  * selected text is taken first by the text menu (`editor/textContextMenu`), which stands ahead
  * of this one and hands back a click with nothing selected inside a cell.
  */
-import { type Command, type EditorState, Plugin } from "prosemirror-state";
+import { type Command, type EditorState, type Plugin } from "prosemirror-state";
 /** Where the menu should stand (viewport coordinates) */
 export interface TableMenuAnchor {
     clientX: number;

package/dist/editor/plugins/tableContextMenu.js

@@ -1,29 +1,14 @@
 // src/editor/plugins/tableContextMenu.ts
 import {
-  Plugin,
-  PluginKey,
   TextSelection
 } from "prosemirror-state";
 import { editsShut } from "../../schema/protectionState.js";
-var CLOSE = "close";
-var menuKey = new PluginKey("docxEditorTableMenu");
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function toAnchor(value) {
-  if (!isRecord(value)) return null;
+import { panelPlugin } from "./panelState.js";
+function isTableMenuAnchor(value) {
+  if (typeof value !== "object" || value === null) return false;
   const { clientX, clientY } = value;
-  if (typeof clientX !== "number" || typeof clientY !== "number") return null;
-  return { clientX, clientY };
-}
-function tableMenuAnchor(state) {
-  return menuKey.getState(state) ?? null;
+  return typeof clientX === "number" && typeof clientY === "number";
 }
-var closeTableMenu = (state, dispatch) => {
-  if (tableMenuAnchor(state) === null) return false;
-  if (dispatch) dispatch(state.tr.setMeta(menuKey, CLOSE));
-  return true;
-};
 function cellStart($pos) {
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
     if ($pos.node(depth).type.spec.tableRole === "cell") {
@@ -46,41 +31,39 @@ function selectionCovers(state, cellPos) {
 }
 function openMenu(view, cellPos, anchor) {
   const state = view.state;
-  const tr = state.tr.setMeta(menuKey, anchor);
+  const tr = menu.opening(state.tr, anchor);
   if (!selectionCovers(state, cellPos)) {
     tr.setSelection(TextSelection.near(tr.doc.resolve(cellPos + 1)));
   }
   view.dispatch(tr);
 }
-function tableContextMenu() {
-  return new Plugin({
-    key: menuKey,
-    state: {
-      init: () => null,
-      apply: (tr, current) => {
-        const meta = tr.getMeta(menuKey);
-        if (meta === CLOSE) return null;
-        const anchor = toAnchor(meta);
-        if (anchor) return anchor;
-        return tr.docChanged ? null : current;
-      }
-    },
-    props: {
-      handleDOMEvents: {
-        contextmenu(view, event) {
-          if (editsShut(view.state)) return false;
-          const cellPos = cellAtEvent(view, event.target);
-          if (cellPos === null) return false;
-          event.preventDefault();
-          openMenu(view, cellPos, {
-            clientX: event.clientX,
-            clientY: event.clientY
-          });
-          return true;
-        }
+var menu = panelPlugin({
+  name: "docxEditorTableMenu",
+  isAnchor: isTableMenuAnchor,
+  // Once the document changes, the cell the menu pointed at may no longer be there
+  onDocChange: "close",
+  props: {
+    handleDOMEvents: {
+      contextmenu(view, event) {
+        if (editsShut(view.state)) return false;
+        const cellPos = cellAtEvent(view, event.target);
+        if (cellPos === null) return false;
+        event.preventDefault();
+        openMenu(view, cellPos, {
+          clientX: event.clientX,
+          clientY: event.clientY
+        });
+        return true;
       }
     }
-  });
+  }
+});
+function tableMenuAnchor(state) {
+  return menu.anchor(state);
+}
+var closeTableMenu = menu.close;
+function tableContextMenu() {
+  return menu.plugin;
 }
 export {
   closeTableMenu,

package/dist/editor/plugins/tableDisplay.js

@@ -1,14 +1,28 @@
 // src/editor/plugins/tableDisplay.ts
+import { tableStyleAttrs } from "../../docx/formatting.js";
+import { parsePropsXml } from "../../ooxml/props.js";
 import { cellFixes, sameFormattingInputs } from "../../table/gridBorders.js";
 var tableDisplay = {
   name: "table",
   nodeTypes: ["table"],
-  derive(table, pos, _doc, _context, previous) {
+  derive(table, pos, _doc, context, previous) {
     if (previous !== null && sameFormattingInputs(previous, table)) return [];
-    return cellFixes(table).map((fix) => ({
-      pos: pos + 1 + fix.pos,
-      attrs: fix.attrs
-    }));
+    const tblPr = table.attrs.tblPr;
+    const attrs = {
+      ...table.attrs,
+      ...tableStyleAttrs(
+        typeof tblPr === "string" ? parsePropsXml(tblPr) : null,
+        context.document.formatting
+      )
+    };
+    const current = table.hasMarkup(table.type, attrs, table.marks) ? table : table.type.create(attrs, table.content, table.marks);
+    return [
+      { pos, attrs },
+      ...cellFixes(current).map((fix) => ({
+        pos: pos + 1 + fix.pos,
+        attrs: fix.attrs
+      }))
+    ];
   }
 };
 export {

package/dist/editor/plugins/textContextMenu.d.ts

@@ -2,7 +2,7 @@
  * Replaces the native text context menu and moves the selection to the clicked position. Unselected
  * table cells are left to the table context-menu plugin.
  */
-import { type Command, type EditorState, Plugin } from "prosemirror-state";
+import { type Command, type EditorState, type Plugin } from "prosemirror-state";
 /** Where the menu should stand (viewport coordinates) */
 export interface TextMenuAnchor {
     clientX: number;

package/dist/editor/plugins/textContextMenu.js

@@ -1,30 +1,15 @@
 // src/editor/plugins/textContextMenu.ts
 import {
-  Plugin,
-  PluginKey,
   TextSelection
 } from "prosemirror-state";
 import { CellSelection } from "prosemirror-tables";
 import { editingProtection, editsShut } from "../../schema/protectionState.js";
-var CLOSE = "close";
-var menuKey = new PluginKey("docxEditorTextMenu");
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function toAnchor(value) {
-  if (!isRecord(value)) return null;
+import { panelPlugin } from "./panelState.js";
+function isTextMenuAnchor(value) {
+  if (typeof value !== "object" || value === null) return false;
   const { clientX, clientY } = value;
-  if (typeof clientX !== "number" || typeof clientY !== "number") return null;
-  return { clientX, clientY };
-}
-function textMenuAnchor(state) {
-  return menuKey.getState(state) ?? null;
+  return typeof clientX === "number" && typeof clientY === "number";
 }
-var closeTextMenu = (state, dispatch) => {
-  if (textMenuAnchor(state) === null) return false;
-  if (dispatch) dispatch(state.tr.setMeta(menuKey, CLOSE));
-  return true;
-};
 function isInEditor(view, target) {
   return target instanceof Node && view.dom.contains(target);
 }
@@ -50,43 +35,41 @@ function forTableMenu(view, target, spot) {
   return aboutCells && isInTableCell(view, target);
 }
 function openMenu(state, event, spot) {
-  const tr = state.tr.setMeta(menuKey, {
+  const tr = menu.opening(state.tr, {
     clientX: event.clientX,
     clientY: event.clientY
   });
   if (isInSelection(state, spot)) return tr;
   return tr.setSelection(TextSelection.near(tr.doc.resolve(spot)));
 }
-function textContextMenu() {
-  return new Plugin({
-    key: menuKey,
-    state: {
-      init: () => null,
-      apply: (tr, current) => {
-        const meta = tr.getMeta(menuKey);
-        if (meta === CLOSE) return null;
-        const anchor = toAnchor(meta);
-        if (anchor) return anchor;
-        return tr.docChanged ? null : current;
-      }
-    },
-    props: {
-      handleDOMEvents: {
-        contextmenu(view, event) {
-          if (editingProtection(view.state) === "readOnly") return false;
-          if (!isInEditor(view, event.target)) return false;
-          const spot = clickedSpot(view, event);
-          if (editsShut(view.state) && !isInSelection(view.state, spot)) {
-            return false;
-          }
-          if (forTableMenu(view, event.target, spot)) return false;
-          event.preventDefault();
-          view.dispatch(openMenu(view.state, event, spot));
-          return true;
+var menu = panelPlugin({
+  name: "docxEditorTextMenu",
+  isAnchor: isTextMenuAnchor,
+  // Once the document changes, what the menu was aimed at may no longer be there
+  onDocChange: "close",
+  props: {
+    handleDOMEvents: {
+      contextmenu(view, event) {
+        if (editingProtection(view.state) === "readOnly") return false;
+        if (!isInEditor(view, event.target)) return false;
+        const spot = clickedSpot(view, event);
+        if (editsShut(view.state) && !isInSelection(view.state, spot)) {
+          return false;
         }
+        if (forTableMenu(view, event.target, spot)) return false;
+        event.preventDefault();
+        view.dispatch(openMenu(view.state, event, spot));
+        return true;
       }
     }
-  });
+  }
+});
+function textMenuAnchor(state) {
+  return menu.anchor(state);
+}
+var closeTextMenu = menu.close;
+function textContextMenu() {
+  return menu.plugin;
 }
 export {
   closeTextMenu,

package/dist/model/format.d.ts

@@ -188,6 +188,45 @@ export interface CellMargins {
     bottomPt: number | null;
     leftPt: number | null;
 }
+/**
+ * The parts of a table a table style formats conditionally (`w:tblStylePr/@w:type`,
+ * ST_TblStyleOverrideType), in the order ECMA-376 Part 1 §17.7.6 applies them: a format standing
+ * later in this list is laid over one standing earlier.
+ */
+export declare const TABLE_STYLE_CONDITIONS: readonly ["wholeTable", "band1Vert", "band2Vert", "band1Horz", "band2Horz", "firstRow", "lastRow", "firstCol", "lastCol", "nwCell", "neCell", "swCell", "seCell"];
+export type TableStyleOverrideType = (typeof TABLE_STYLE_CONDITIONS)[number];
+/**
+ * How many rows one row band and how many columns one column band are made of
+ * (`w:tblStyleRowBandSize`, `w:tblStyleColBandSize`). A style that says nothing leaves the side
+ * null, and its bands are then one row or one column wide.
+ */
+export interface BandSizes {
+    row: number | null;
+    col: number | null;
+}
+/** The lines one conditional format draws around the region it covers. A side it says nothing about is null */
+export interface CellStyleBorders {
+    top: string | null;
+    bottom: string | null;
+    left: string | null;
+    right: string | null;
+}
+/**
+ * What one conditional format of a table style lays down for the cells it covers.
+ *
+ * Its lines are those of the region: `borders` is drawn where a cell lies on the edge of the
+ * region and `inside` between the cells within it, the same way a table's own lines are drawn
+ * around and between its cells.
+ */
+export interface CellStyleFormat {
+    background: string | null;
+    borders: CellStyleBorders;
+    inside: InsideBorders;
+    margins: CellMargins;
+    verticalAlign: CellVerticalAlign | null;
+}
+/** The conditional formats a table style lays down for its cells, by the part of the table each covers */
+export type TableStyleConditions = Readonly<Partial<Record<TableStyleOverrideType, CellStyleFormat>>>;
 /**
  * How high a row stands, in points.
  * `atLeast` is a floor the row grows past when its text needs the room, and `exact` pins
@@ -251,6 +290,17 @@ export declare function toInsideBorders(value: unknown): InsideBorders | null;
  * there at all, so it is null.
  */
 export declare function toCellMargins(value: unknown): CellMargins | null;
+/**
+ * The band sizes a table style laid down, as they come back in from `data-style-bands`.
+ * A style that said nothing about either is the same as the attribute not being there at all.
+ */
+export declare function toBandSizes(value: unknown): BandSizes | null;
+/**
+ * The conditional formats a table style laid down for its cells, as they come back in from
+ * `data-style-conditions`. A part no table has is not one this editor draws, so it is dropped;
+ * a table whose style dresses no part at all is the same as the attribute not being there.
+ */
+export declare function toTableStyleConditions(value: unknown): TableStyleConditions | null;
 export declare function toRowFormat(value: unknown): RowFormat | null;
 export declare function toCellFormat(value: unknown): CellFormat | null;
 /**

package/dist/model/format.js

@@ -74,6 +74,21 @@ var RUN_FORMAT_KEYS = [
   "verticalAlign",
   "lang"
 ];
+var TABLE_STYLE_CONDITIONS = [
+  "wholeTable",
+  "band1Vert",
+  "band2Vert",
+  "band1Horz",
+  "band2Horz",
+  "firstRow",
+  "lastRow",
+  "firstCol",
+  "lastCol",
+  "nwCell",
+  "neCell",
+  "swCell",
+  "seCell"
+];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -261,6 +276,53 @@ function toCellMargins(value) {
   ];
   return sides.every((side) => side === null) ? null : margins;
 }
+function toBandSizes(value) {
+  if (!isRecord(value)) return null;
+  const size = (side) => typeof side === "number" && Number.isInteger(side) && side > 0 ? side : null;
+  const bands = { row: size(value.row), col: size(value.col) };
+  return bands.row === null && bands.col === null ? null : bands;
+}
+function toCellStyleBorders(value) {
+  if (!isRecord(value)) {
+    return { top: null, bottom: null, left: null, right: null };
+  }
+  return {
+    top: matching(BORDER_CSS, value.top) ?? null,
+    bottom: matching(BORDER_CSS, value.bottom) ?? null,
+    left: matching(BORDER_CSS, value.left) ?? null,
+    right: matching(BORDER_CSS, value.right) ?? null
+  };
+}
+function toCellStyleFormat(value) {
+  if (!isRecord(value)) return null;
+  return {
+    background: matching(FILL, value.background) ?? null,
+    borders: toCellStyleBorders(value.borders),
+    inside: toInsideBorders(value.inside) ?? {
+      horizontal: null,
+      vertical: null
+    },
+    margins: toCellMargins(value.margins) ?? {
+      topPt: null,
+      rightPt: null,
+      bottomPt: null,
+      leftPt: null
+    },
+    verticalAlign: isCellVerticalAlign(value.verticalAlign) ? value.verticalAlign : null
+  };
+}
+function toTableStyleConditions(value) {
+  if (!isRecord(value)) return null;
+  const conditions = {};
+  let found = false;
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const format = toCellStyleFormat(value[type]);
+    if (format === null) continue;
+    conditions[type] = format;
+    found = true;
+  }
+  return found ? conditions : null;
+}
 function toRowHeight(value) {
   if (!isRecord(value) || typeof value.pt !== "number") return null;
   if (value.rule === "exact") return { rule: "exact", pt: value.pt };
@@ -300,9 +362,11 @@ function spanCount(value) {
 export {
   NO_FILL,
   RUN_FORMAT_KEYS,
+  TABLE_STYLE_CONDITIONS,
   isHighlightName,
   isUnderlineKind,
   spanCount,
+  toBandSizes,
   toCellFormat,
   toCellMargins,
   toColWidth,
@@ -312,6 +376,7 @@ export {
   toRowFormat,
   toRunFormat,
   toTableFormat,
+  toTableStyleConditions,
   toTableWidth,
   widthNumber,
   withWidthNumber

package/dist/numbering/listRegistry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The register of list definitions a document node carries.
+ *
+ * A list started while editing is registered with the definition it was started with, and the
+ * register rides on the document node itself: undo takes a registration back with the edit that
+ * made it, and the export writes out what was registered rather than working a definition out for
+ * itself. Only what `abstractNumXml` writes in full may be registered, and the value is read back
+ * through this file so that nothing else can end up in the register.
+ */
+import { type NewList } from "./parseNumbering";
+/** The lists registered on one document, by the number each was given */
+export type NewLists = ReadonlyMap<number, NewList>;
+export declare const NO_NEW_LISTS: NewLists;
+/** The document attr the register travels on */
+export declare const NEW_LISTS_ATTR = "newLists";
+/**
+ * What the document node carries for a register.
+ *
+ * The entries run in the order of the numbers they define so that the same register is always the
+ * same value, whichever order the lists were started in, and an empty register is the null a
+ * document that never started a list carries: a list left is then a list never started.
+ */
+export declare function newListsValue(lists: NewLists): unknown;
+/**
+ * The register a document node carries. Empty for a node carrying none, and for one carrying an
+ * entry that is not a list definition: a definition the writer cannot read back in full is a
+ * definition it must not write half of.
+ */
+export declare function newListsOf(value: unknown): NewLists;
+/**
+ * The register with the definitions of the lists nothing wears any more taken out.
+ *
+ * A number goes back into circulation with its definition, so leaving a list is exactly what
+ * joining it was not: pressing the list button twice gives back the document that was there
+ * before the first press.
+ */
+export declare function listsWorn(lists: NewLists, worn: ReadonlySet<number>): NewLists;