@portone/docx-editor 0.2.1 → 0.4.0

package/dist/editor/commands/formatting/editing.d.ts

@@ -1,6 +1,5 @@
-/** Applies inline formatting while preserving each run's untouched XML. */
+/** The character formatting commands the package exports, each built from the property it edits. */
 import type { Command, EditorState } from "prosemirror-state";
-export type { RunToggle } from "../../../docx/runProps";
 /**
  * Whether character formatting reaches anything where the selection stands, which is what a
  * control offering it is drawn from.
@@ -13,6 +12,7 @@ export type { RunToggle } from "../../../docx/runProps";
 export declare function canFormatText(state: EditorState): boolean;
 export declare const toggleBold: Command;
 export declare const toggleItalic: Command;
+/** Switching the underline on writes a single one; a run already underlined keeps the kind it has */
 export declare const toggleUnderline: Command;
 export declare const toggleStrike: Command;
 /** Sets the font size in points. Null withdraws the setting and falls back to the document default */

package/dist/editor/commands/formatting/editing.js

@@ -1,130 +1,48 @@
 // src/editor/commands/formatting/editing.ts
-import {
-  editRunProps,
-  isRunToggleOn,
-  matchesRunEdit
-} from "../../../docx/runProps.js";
-import { docxSchema } from "../../../schema/index.js";
-import {
-  insertionInsideLocked,
-  rangeTouchesLocked
-} from "../../../schema/locks.js";
-import { editsShut } from "../../../schema/protectionState.js";
-import {
-  activePieces,
-  caretPiece,
-  text,
-  textPieces
-} from "./shared.js";
-function editedMark(target, edit) {
-  const next = editRunProps(
-    { rPr: text(target.mark?.attrs.rPr), format: target.format },
-    target.pPr,
-    edit
-  );
-  if (!next) return null;
-  return docxSchema.marks.run.create({
-    ...target.mark?.attrs,
-    rPr: next.rPr,
-    format: next.format
-  });
-}
-function planChanges(pieces, edit) {
-  const changes = [];
-  for (const target of pieces) {
-    const mark = editedMark(target, edit);
-    if (!mark) return null;
-    changes.push({ from: target.from, to: target.to, mark });
-  }
-  return changes;
-}
-function applyToSelection(state, dispatch, edit) {
-  const pieces = textPieces(state).filter(
-    (target) => (
-      // Text already in the desired state is left untouched, so its original XML survives
-      !matchesRunEdit(target.format, edit) && // A locked stretch is left out rather than refused: the guard turns down the whole
-      // transaction, so asking for it would leave the rest of the selection unformatted too
-      !rangeTouchesLocked(state.doc, target.from, target.to)
-    )
-  );
-  const changes = pieces.length > 0 ? planChanges(pieces, edit) : null;
-  if (!changes) return false;
-  if (dispatch) {
-    const tr = state.tr;
-    for (const change of changes) {
-      tr.addMark(change.from, change.to, change.mark);
-    }
-    dispatch(tr);
-  }
-  return true;
-}
-function applyToCaret(state, dispatch, edit) {
-  const target = caretPiece(state);
-  if (matchesRunEdit(target.format, edit)) return false;
-  const mark = editedMark(target, edit);
-  if (!mark) return false;
-  if (dispatch) {
-    const marks = state.storedMarks ?? state.selection.$from.marks();
-    dispatch(state.tr.setStoredMarks(mark.addToSet(marks)));
-  }
-  return true;
-}
-function runEditCommand(edit) {
-  return (state, dispatch) => {
-    if (editsShut(state)) return false;
-    return state.selection.empty ? applyToCaret(state, dispatch, edit) : applyToSelection(state, dispatch, edit);
-  };
-}
+import { editShut, openStretches } from "../../../schema/guards.js";
+import { runPropertyCommands } from "./propertyCommands.js";
+import { textPieces } from "./shared.js";
 function canFormatText(state) {
-  if (editsShut(state)) return false;
   if (state.selection.empty) {
-    return !insertionInsideLocked(state.doc, state.selection.from);
+    return !editShut(state, { kind: "insert", at: state.selection.from });
   }
-  return textPieces(state).some(
-    (target) => !rangeTouchesLocked(state.doc, target.from, target.to)
-  );
-}
-function isToggleActive(state, toggle) {
-  const pieces = activePieces(state);
-  return pieces.length > 0 && pieces.every((target) => isRunToggleOn(target.format, toggle));
-}
-function toggleCommand(toggle) {
-  return (state, dispatch) => {
-    const edit = {
-      kind: "toggle",
-      toggle,
-      on: !isToggleActive(state, toggle)
-    };
-    return runEditCommand(edit)(state, dispatch);
-  };
-}
-var toggleBold = toggleCommand("bold");
-var toggleItalic = toggleCommand("italic");
-var toggleUnderline = toggleCommand("underline");
-var toggleStrike = toggleCommand("strike");
+  return openStretches(state, textPieces(state), "mark").length > 0;
+}
+var bold = runPropertyCommands("bold");
+var italic = runPropertyCommands("italic");
+var underline = runPropertyCommands("underline");
+var strike = runPropertyCommands("strike");
+var fontSize = runPropertyCommands("fontSizePt");
+var fontFamily = runPropertyCommands("fontFamily");
+var textColor = runPropertyCommands("color");
+var textBackground = runPropertyCommands("background");
+var toggleBold = bold.toggle(true);
+var toggleItalic = italic.toggle(true);
+var toggleUnderline = underline.toggle("single");
+var toggleStrike = strike.toggle(true);
 function setFontSize(pt) {
-  return runEditCommand({ kind: "fontSize", pt });
+  return fontSize.set(pt);
 }
 function setFontFamily(name) {
-  return runEditCommand({ kind: "fontFamily", name });
+  return fontFamily.set(name);
 }
 function setTextColor(hex) {
-  return runEditCommand({ kind: "color", hex });
+  return textColor.set(hex);
 }
 function setTextBackground(hex) {
-  return runEditCommand({ kind: "background", hex });
+  return textBackground.set(hex);
 }
 function isBoldActive(state) {
-  return isToggleActive(state, "bold");
+  return bold.isActive(state);
 }
 function isItalicActive(state) {
-  return isToggleActive(state, "italic");
+  return italic.isActive(state);
 }
 function isUnderlineActive(state) {
-  return isToggleActive(state, "underline");
+  return underline.isActive(state);
 }
 function isStrikeActive(state) {
-  return isToggleActive(state, "strike");
+  return strike.isActive(state);
 }
 export {
   canFormatText,

package/dist/editor/commands/formatting/propertyCommands.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The commands and the query one run property is edited and read through, built from the
+ * property's row in the run property table.
+ *
+ * Each edit preserves the run's untouched XML: the row says which children of the rPr change,
+ * and the mark keeps every other attr it wore.
+ */
+import type { Command, EditorState } from "prosemirror-state";
+import { type EditableRunKey, type RunSetting } from "../../../docx/formatting";
+export interface RunPropertyCommands<K extends EditableRunKey> {
+    /** Writes the value into the selection. Null withdraws the run's own setting, so the layers below decide again */
+    set(value: RunSetting<K> | null): Command;
+    /** Whether the property is on where the selection stands. It counts as on only when it is on everywhere */
+    isActive(state: EditorState): boolean;
+    /**
+     * The same toggle convention as Word: if every character in the selection is already on, turn
+     * them all off; otherwise switch them all on as `on`.
+     */
+    toggle(on: RunSetting<K>): Command;
+}
+export declare function runPropertyCommands<K extends EditableRunKey>(key: K): RunPropertyCommands<K>;

package/dist/editor/commands/formatting/propertyCommands.js

@@ -0,0 +1,108 @@
+// src/editor/commands/formatting/propertyCommands.ts
+import {
+  inheritedRunFormat,
+  RUN_PROPERTIES,
+  resolveParagraph,
+  resolveRun
+} from "../../../docx/formatting.js";
+import {
+  editRunProps,
+  matchesRunEdit
+} from "../../../docx/runProps.js";
+import { docxSchema } from "../../../schema/index.js";
+import { editShut, openStretches } from "../../../schema/guards.js";
+import { documentFormatting } from "../../documentStyles.js";
+import { paragraphPlacementAt } from "../../paragraphPlacement.js";
+import {
+  activePieces,
+  caretPiece,
+  text,
+  textPieces
+} from "./shared.js";
+function editedMark(state, target, edit) {
+  const context = documentFormatting(state);
+  const rPr = text(target.mark?.attrs.rPr);
+  const paragraph = resolveParagraph(
+    target.pPr,
+    context,
+    paragraphPlacementAt(state.doc, target.from)
+  );
+  const next = editRunProps(
+    { rPr, format: target.format },
+    inheritedRunFormat(rPr, paragraph, context),
+    edit
+  );
+  if (!next) return null;
+  return docxSchema.marks.run.create({
+    ...target.mark?.attrs,
+    rPr: next.rPr,
+    format: resolveRun(next.rPr, paragraph, context)
+  });
+}
+function planChanges(state, pieces, edit) {
+  const changes = [];
+  for (const target of pieces) {
+    const mark = editedMark(state, target, edit);
+    if (!mark) return null;
+    changes.push({ from: target.from, to: target.to, mark });
+  }
+  return changes;
+}
+function applyToSelection(state, dispatch, edit) {
+  const pieces = openStretches(
+    state,
+    // Text already in the desired state is left untouched, so its original XML survives
+    textPieces(state).filter((target) => !matchesRunEdit(target.format, edit)),
+    "mark"
+  );
+  const changes = pieces.length > 0 ? planChanges(state, pieces, edit) : null;
+  if (!changes) return false;
+  if (dispatch) {
+    const tr = state.tr;
+    for (const change of changes) {
+      tr.addMark(change.from, change.to, change.mark);
+    }
+    dispatch(tr);
+  }
+  return true;
+}
+function applyToCaret(state, dispatch, edit) {
+  if (editShut(state, { kind: "insert", at: state.selection.from })) {
+    return false;
+  }
+  const target = caretPiece(state);
+  if (matchesRunEdit(target.format, edit)) return false;
+  const mark = editedMark(state, target, edit);
+  if (!mark) return false;
+  if (dispatch) {
+    const marks = state.storedMarks ?? state.selection.$from.marks();
+    dispatch(state.tr.setStoredMarks(mark.addToSet(marks)));
+  }
+  return true;
+}
+function runEditCommand(edit) {
+  return (state, dispatch) => state.selection.empty ? applyToCaret(state, dispatch, edit) : applyToSelection(state, dispatch, edit);
+}
+function runPropertyCommands(key) {
+  const property = RUN_PROPERTIES[key];
+  const isOn = (target) => property.isOn(target.format ?? {});
+  const set = (value) => runEditCommand({ key, value });
+  return {
+    set,
+    isActive: (state) => {
+      const pieces = activePieces(state);
+      return pieces.length > 0 && pieces.every(isOn);
+    },
+    toggle: (on) => (state, dispatch) => {
+      const pieces = openStretches(
+        state,
+        state.selection.empty ? [caretPiece(state)] : textPieces(state),
+        "mark"
+      );
+      return set(pieces.every(isOn) ? null : on)(state, dispatch);
+    }
+  };
+}
+export {
+  runPropertyCommands
+};

package/dist/editor/commands/formatting/shared.d.ts

@@ -25,8 +25,8 @@ export declare function textPieces(state: EditorState): TextPiece[];
 /** When the selection is collapsed, the formatting that text typed next will follow */
 export declare function caretPiece(state: EditorState): TextPiece;
 /**
- * The places formatting currently applies to: a single caret, or the text pieces of the selection
- * a lock leaves open. It has to leave out what `applyToSelection` leaves out, or a toggle reads off
- * for text that is already on and can never turn it off.
+ * The formatting a toolbar reads, excluding locked text as it does during editing.
+ * Document protection prevents edits, but must not hide the selected text's actual formatting.
+ * Commands separately ask all guards before deciding what they can change.
  */
 export declare function activePieces(state: EditorState): TextPiece[];

package/dist/editor/commands/formatting/shared.js

@@ -1,7 +1,7 @@
 // src/editor/commands/formatting/shared.ts
 import { toRunFormat } from "../../../model/format.js";
 import { docxSchema } from "../../../schema/index.js";
-import { rangeTouchesLocked } from "../../../schema/locks.js";
+import { lockGuard } from "../../../schema/locks.js";
 function text(value) {
   return typeof value === "string" ? value : null;
 }
@@ -41,7 +41,10 @@ function caretPiece(state) {
 function activePieces(state) {
   if (state.selection.empty) return [caretPiece(state)];
   return textPieces(state).filter(
-    (target) => !rangeTouchesLocked(state.doc, target.from, target.to)
+    (target) => !lockGuard.shuts(
+      { kind: "mark", from: target.from, to: target.to },
+      state
+    )
   );
 }
 export {

package/dist/editor/commands/indentCommands.js

@@ -1,6 +1,7 @@
 // src/editor/commands/indentCommands.ts
 import { withLeftIndent, withListNumbering } from "../../docx/paraProps.js";
 import { toParagraphFormat } from "../../model/format.js";
+import { TWIPS_PER_PT } from "../../ooxml/simpleTypes.js";
 import { editParagraphs, paragraphPPr } from "../paragraphEdits.js";
 import { documentNumbering } from "../plugins/numberingDecorations.js";
 import { listLevelChange, listRefOf } from "./listCommands.js";
@@ -8,7 +9,7 @@ var STEP_TWIPS = 720;
 function leftIndentTwips(node) {
   const format = toParagraphFormat(node.attrs.format);
   const pt = format?.indentStartPt ?? format?.indentLeftPt ?? 0;
-  return Math.round(pt * 20);
+  return Math.round(pt * TWIPS_PER_PT);
 }
 function steppedLeftTwips(node, delta) {
   const left = leftIndentTwips(node);
@@ -18,13 +19,13 @@ function steppedLeftTwips(node, delta) {
 function indentStep(delta) {
   return (state, dispatch) => {
     const numbering = documentNumbering(state);
-    return editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
+    return editParagraphs(state, dispatch, (node) => {
       if (listRefOf(node)) {
         const change = listLevelChange(numbering, node, delta);
-        return change && withListNumbering(paragraphPPr(node), change, styles, defaultStyleId);
+        return change && withListNumbering(paragraphPPr(node), change);
       }
       const left = steppedLeftTwips(node, delta);
-      return left === null ? null : withLeftIndent(paragraphPPr(node), left, styles, defaultStyleId);
+      return left === null ? null : withLeftIndent(paragraphPPr(node), left);
     });
   };
 }

package/dist/editor/commands/index.d.ts

@@ -13,6 +13,8 @@ export type { ParagraphStyleOption } from "../../docx/formatting";
 export type { RunToggle } from "../../docx/runProps";
 export type { LineSpacing, ParagraphAlign } from "../../model/format";
 export type { ListKind } from "../../numbering/listTemplate";
+/** The codes a problem below is reported under, which are the ones `DocxExportError` is thrown with */
+export type { DocxExportErrorCode } from "../../ooxml/errors";
 /** The size an image is shown at, which the insert command asks for */
 export type { ImageExtent } from "../../ooxml/image";
 /**
@@ -56,6 +58,15 @@ export { insertLineBreak, insertPageBreak } from "./breakCommands";
 export { canRunCommand } from "./canRunCommand";
 export type { CommentAuthor, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
 export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
+/**
+ * Whether the document as it stands can be written back, and every reason it could not, each
+ * with the code `exportDocx` would throw it under. `canExport` is what an export control is
+ * drawn from, and `downloadDocx` answers `blocked` with the same list.
+ */
+export type { ExportProblem } from "./exportQueries";
+export { canExport, documentExportProblems } from "./exportQueries";
+export type { FidelityCode, FidelityNote, FidelitySeverity, } from "./fidelityQueries";
+export { documentFidelity } from "./fidelityQueries";
 export type { ActiveFontFamily, ActiveFontSize, } from "./formattingCommands";
 export { activeFontFamily, activeFontSize, activeTextBackground, activeTextColor, canFormatText, documentFontNames, isBoldActive, isItalicActive, isStrikeActive, isUnderlineActive, setFontFamily, setFontSize, setTextBackground, setTextColor, toggleBold, toggleItalic, toggleStrike, toggleUnderline, } from "./formattingCommands";
 /**

package/dist/editor/commands/index.js

@@ -29,6 +29,8 @@ import {
   updateComment,
   updateCommentReply
 } from "./commentCommands.js";
+import { canExport, documentExportProblems } from "./exportQueries.js";
+import { documentFidelity } from "./fidelityQueries.js";
 import {
   activeFontFamily,
   activeFontSize,
@@ -111,6 +113,7 @@ export {
   canAddComment,
   canDecreaseIndent,
   canEditComment,
+  canExport,
   canFormatText,
   canIncreaseIndent,
   canInsertImage,
@@ -124,6 +127,8 @@ export {
   documentBodyWidthPx,
   documentComments,
   documentDefaults,
+  documentExportProblems,
+  documentFidelity,
   documentFontNames,
   documentHasLocked,
   documentNotes,

package/dist/editor/commands/linkCommands.js

@@ -1,7 +1,6 @@
 // src/editor/commands/linkCommands.ts
 import { docxSchema } from "../../schema/index.js";
-import { rangeTouchesLocked } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { openStretches } from "../../schema/guards.js";
 var linkType = docxSchema.marks.link;
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -75,10 +74,10 @@ function linkSpansTouching(doc, from, to) {
   return spans;
 }
 function openPieces(state) {
-  if (editsShut(state)) return [];
-  const found = state.selection.empty ? caretPieces(state) : selectionPieces(state);
-  return found.filter(
-    (piece) => !rangeTouchesLocked(state.doc, piece.from, piece.to)
+  return openStretches(
+    state,
+    state.selection.empty ? caretPieces(state) : selectionPieces(state),
+    "mark"
   );
 }
 function caretPieces(state) {

package/dist/editor/commands/listCommands.d.ts

@@ -4,7 +4,8 @@
  * All they do is change a paragraph's place in a list (its numbering id and level).
  * Editing the formatting fragments belongs to `docx/paraProps`, and the list's appearance
  * belongs to `numbering/`.
- * The definition of a new list is not put into the document; numbering.xml picks it up on export.
+ * Starting a list records its definition on the document node in the same transaction, and the
+ * export writes that definition into numbering.xml.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { Command, EditorState } from "prosemirror-state";
@@ -24,6 +25,8 @@ export declare function listLevelChange(numbering: Numbering, node: PMNode, delt
 export declare const increaseListLevel: Command;
 /** Moves a list item one level back up, which is not the paragraph's own indent. What Shift+Tab does */
 export declare const decreaseListLevel: Command;
+/** Every numbering id a paragraph of this document wears */
+export declare function numIdsIn(doc: PMNode): Set<number>;
 /**
  * Takes the selected paragraphs out of the list.
  * Only the hanging indentation the marker sat in goes with it; an indentation the paragraph had
@@ -31,8 +34,8 @@ export declare const decreaseListLevel: Command;
  */
 export declare const removeFromList: Command;
 /**
- * The kind of list the selected paragraphs belong to. Null when they are not a list or the kinds
- * are mixed.
+ * The kind of list the selected paragraphs belong to. Null when they are not a list, when nothing
+ * defines the list they are in, or when the kinds are mixed.
  * It reads the paragraphs a lock leaves open, the same ones `editParagraphs` writes to: counting a
  * locked paragraph that stays out of the list would keep the answer mixed, so the button would make
  * a list a second time instead of taking it off.

package/dist/editor/commands/listCommands.js

@@ -5,12 +5,18 @@ import {
 } from "../../docx/paraProps.js";
 import { toParagraphFormat } from "../../model/format.js";
 import {
+  listsWorn,
+  NEW_LISTS_ATTR,
+  newListsValue
+} from "../../numbering/listRegistry.js";
+import {
+  allocateList,
   listFor,
-  listKindOf,
   MAX_ILVL,
-  nextNumId
+  templateList
 } from "../../numbering/listTemplate.js";
 import { docxSchema } from "../../schema/index.js";
+import { documentFormatting } from "../documentStyles.js";
 import {
   editableParagraphs,
   editParagraphs,
@@ -24,18 +30,25 @@ import {
 function listRefOf(node) {
   return toParagraphFormat(node.attrs.format)?.numbering ?? null;
 }
-function changeParagraphs(state, dispatch, plan) {
-  return editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
-    const change = plan(node);
-    return change && withListNumbering(paragraphPPr(node), change, styles, defaultStyleId);
-  });
+function changeParagraphs(state, dispatch, plan, extras = {
+  alongside: pruneLists(documentNumbering(state).added)
+}) {
+  return editParagraphs(
+    state,
+    dispatch,
+    (node) => {
+      const change = plan(node);
+      return change && withListNumbering(paragraphPPr(node), change);
+    },
+    extras
+  );
 }
 function indentForLevel(numbering, node, ref) {
   const format = toParagraphFormat(node.attrs.format);
   if (format?.indentStartPt === void 0 && format?.indentLeftPt === void 0) {
     return { kind: "keep" };
   }
-  const indent = listFor(numbering, ref.numId).levels.get(ref.ilvl)?.indent;
+  const indent = listFor(numbering, ref.numId)?.levels.get(ref.ilvl)?.indent;
   return indent ? { kind: "level", indent } : { kind: "keep" };
 }
 function listLevelChange(numbering, node, delta) {
@@ -58,24 +71,50 @@ function levelShift(delta) {
 }
 var increaseListLevel = levelShift(1);
 var decreaseListLevel = levelShift(-1);
-function usedNumIds(state, numbering) {
-  const used = new Set(numbering.lists.keys());
-  state.doc.descendants((node) => {
+function numIdsIn(doc) {
+  const worn = /* @__PURE__ */ new Set();
+  doc.descendants((node) => {
     if (node.type !== docxSchema.nodes.paragraph) return true;
     const ref = listRefOf(node);
-    if (ref) used.add(ref.numId);
+    if (ref) worn.add(ref.numId);
     return false;
   });
-  return used;
+  return worn;
+}
+function recordLists(tr, lists) {
+  tr.setDocAttribute(
+    NEW_LISTS_ATTR,
+    newListsValue(listsWorn(lists, numIdsIn(tr.doc)))
+  );
+}
+function pruneLists(lists) {
+  return (tr) => {
+    if (listsWorn(lists, numIdsIn(tr.doc)) !== lists) recordLists(tr, lists);
+  };
 }
 function startList(kind) {
   return (state, dispatch) => {
     if (!canStartNewList(state)) return false;
-    const numId = nextNumId(usedNumIds(state, documentNumbering(state)), kind);
-    return changeParagraphs(state, dispatch, (node) => ({
-      numbering: { numId, ilvl: listRefOf(node)?.ilvl ?? 0 },
-      indent: { kind: "keep" }
-    }));
+    const started = allocateList(
+      documentNumbering(state),
+      numIdsIn(state.doc),
+      templateList(kind)
+    );
+    return changeParagraphs(
+      state,
+      dispatch,
+      (node) => ({
+        numbering: { numId: started.numId, ilvl: listRefOf(node)?.ilvl ?? 0 },
+        indent: { kind: "keep" }
+      }),
+      {
+        formatting: {
+          ...documentFormatting(state),
+          numbering: started.numbering
+        },
+        alongside: (tr) => recordLists(tr, started.numbering.added)
+      }
+    );
   };
 }
 var removeFromList = (state, dispatch) => changeParagraphs(
@@ -84,8 +123,8 @@ var removeFromList = (state, dispatch) => changeParagraphs(
   (node) => listRefOf(node) ? { numbering: null, indent: { kind: "clearHanging" } } : null
 );
 function kindOf(numbering, ref) {
-  const level = listFor(numbering, ref.numId).levels.get(ref.ilvl);
-  if (!level) return listKindOf(ref.numId);
+  const level = listFor(numbering, ref.numId)?.levels.get(ref.ilvl);
+  if (!level) return null;
   return level.format === "bullet" ? "bullet" : "numbered";
 }
 function activeListKind(state) {
@@ -107,16 +146,19 @@ function isInList(state) {
     (spot) => listRefOf(spot.node) !== null
   );
 }
-var leaveListAtLineStart = (state, dispatch) => editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
-  if (!listRefOf(node)) return null;
-  const unlisted = withListNumbering(
-    paragraphPPr(node),
-    { numbering: null, indent: { kind: "clearHanging" } },
-    styles,
-    defaultStyleId
-  );
-  return unlisted && withLeftIndent(unlisted.pPr, 0, styles, defaultStyleId);
-});
+var leaveListAtLineStart = (state, dispatch) => editParagraphs(
+  state,
+  dispatch,
+  (node) => {
+    if (!listRefOf(node)) return null;
+    const unlisted = withListNumbering(paragraphPPr(node), {
+      numbering: null,
+      indent: { kind: "clearHanging" }
+    });
+    return unlisted && withLeftIndent(unlisted.pPr, 0);
+  },
+  { alongside: pruneLists(documentNumbering(state).added) }
+);
 var leaveEmptyListItem = (state, dispatch) => {
   const { empty, $from } = state.selection;
   const paragraph = $from.parent;
@@ -134,6 +176,7 @@ export {
   leaveEmptyListItem,
   listLevelChange,
   listRefOf,
+  numIdsIn,
   removeFromList,
   toggleBulletList,
   toggleNumberedList

package/dist/editor/commands/lockCommands.d.ts

@@ -25,7 +25,13 @@ export declare function selectionLock(state: EditorState): SelectionLock;
  * A selection that also reaches a lock still locks what that lock leaves open.
  */
 export declare const lockSelection: Command;
-/** Lifts the lock off every control the selection reaches, over that control's whole stretch */
+/**
+ * Lifts the lock off every control the selection reaches, over that control's whole stretch.
+ *
+ * The transaction carries the pass that lets it reach past the very locks it lifts, which is the
+ * one thing the pass is for; every other guard still has its say, so lifting a lock stays shut
+ * under a protection that shuts the body (`schema/guards`).
+ */
 export declare const unlockSelection: Command;
 /**
  * Whether editing where the selection stands is shut.