@portone/docx-editor 0.1.0

package/dist/editor/commands/linkCommands.js

@@ -0,0 +1,146 @@
+// src/editor/commands/linkCommands.ts
+import { docxSchema } from "../../schema/index.js";
+import { rangeTouchesLocked } from "../../schema/locks.js";
+var linkType = docxSchema.marks.link;
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+var NAMES_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+var MEANS_A_PLACE = /^[./#]/;
+function settled(address) {
+  const typed = address.trim();
+  if (NAMES_SCHEME.test(typed) || MEANS_A_PLACE.test(typed)) return typed;
+  const host = typed.split(/[/?#]/, 1)[0];
+  return host.includes(".") ? `http://${typed}` : typed;
+}
+function linkMarkOf(marks) {
+  return marks.find((mark) => mark.type === linkType) ?? null;
+}
+function linkable(node, parent) {
+  if (parent === null || !parent.type.allowsMarkType(linkType)) return false;
+  return node.isText || node.type.allowsMarkType(linkType);
+}
+function piecesIn(doc, from, to) {
+  const pieces = [];
+  doc.nodesBetween(from, to, (node, pos, parent) => {
+    if (!node.isInline) return true;
+    if (!linkable(node, parent)) return false;
+    const start = Math.max(pos, from);
+    const end = Math.min(pos + node.nodeSize, to);
+    if (start < end) {
+      pieces.push({ from: start, to: end, link: linkMarkOf(node.marks) });
+    }
+    return false;
+  });
+  return pieces;
+}
+function linkSpans(parent, start) {
+  const spans = [];
+  parent.forEach((child, offset) => {
+    const link = linkMarkOf(child.marks);
+    if (!link) return;
+    const from = start + offset;
+    const to = from + child.nodeSize;
+    const last = spans.at(-1);
+    if (last && last.to === from && last.link.eq(link)) last.to = to;
+    else spans.push({ from, to, link });
+  });
+  return spans;
+}
+function caretSpan(state) {
+  const $from = state.selection.$from;
+  const link = linkMarkOf($from.marks());
+  if (!link) return null;
+  return linkSpans($from.parent, $from.start()).find(
+    (span) => span.link.eq(link) && span.from <= $from.pos && $from.pos <= span.to
+  ) ?? null;
+}
+function selectionSpan(state) {
+  const { $from, $to } = state.selection;
+  if (!$from.parent.isTextblock || $from.parent !== $to.parent) return null;
+  return linkSpans($from.parent, $from.start()).find(
+    (span) => span.from <= $from.pos && $to.pos <= span.to
+  ) ?? null;
+}
+function linkSpansTouching(doc, from, to) {
+  const spans = [];
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isTextblock) return true;
+    for (const span of linkSpans(node, pos + 1)) {
+      if (span.from < to && from < span.to) spans.push(span);
+    }
+    return false;
+  });
+  return spans;
+}
+function openPieces(state) {
+  const found = state.selection.empty ? caretPieces(state) : selectionPieces(state);
+  return found.filter(
+    (piece) => !rangeTouchesLocked(state.doc, piece.from, piece.to)
+  );
+}
+function caretPieces(state) {
+  const span = caretSpan(state);
+  return span === null ? [] : [span];
+}
+function selectionPieces(state) {
+  return state.selection.ranges.flatMap((range) => [
+    ...linkSpansTouching(state.doc, range.$from.pos, range.$to.pos),
+    ...piecesIn(state.doc, range.$from.pos, range.$to.pos).filter(
+      (piece) => piece.link === null
+    )
+  ]);
+}
+function linkMarkFor(piece, href) {
+  return linkType.create({ ...piece.link?.attrs, href });
+}
+function setLink(url) {
+  return (state, dispatch) => {
+    const href = settled(url);
+    if (href === "") return false;
+    const pieces = openPieces(state).filter(
+      (piece) => text(piece.link?.attrs.href) !== href
+    );
+    if (pieces.length === 0) return false;
+    if (dispatch) {
+      const tr = state.tr;
+      for (const piece of pieces) {
+        tr.addMark(piece.from, piece.to, linkMarkFor(piece, href));
+      }
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+var removeLink = (state, dispatch) => {
+  const pieces = openPieces(state).filter((piece) => piece.link !== null);
+  if (pieces.length === 0) return false;
+  if (dispatch) {
+    const tr = state.tr;
+    for (const piece of pieces) {
+      tr.removeMark(piece.from, piece.to, linkType);
+    }
+    dispatch(tr);
+  }
+  return true;
+};
+function canSetLink(state) {
+  return openPieces(state).length > 0;
+}
+function activeLink(state) {
+  const pieces = openPieces(state);
+  const first = text(pieces[0]?.link?.attrs.href);
+  return pieces.every((piece) => text(piece.link?.attrs.href) === first) ? first : null;
+}
+function activeLinkSpan(state) {
+  const span = state.selection.empty ? caretSpan(state) : selectionSpan(state);
+  if (!span) return null;
+  return { from: span.from, to: span.to, href: text(span.link.attrs.href) };
+}
+export {
+  activeLink,
+  activeLinkSpan,
+  canSetLink,
+  removeLink,
+  setLink
+};

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

@@ -0,0 +1,58 @@
+/**
+ * List editing commands.
+ *
+ * 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.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { Command, EditorState } from "prosemirror-state";
+import { type ListChange } from "../../docx/paraProps";
+import { type NumberingRef } from "../../model/format";
+import { type ListKind } from "../../numbering/listTemplate";
+import type { Numbering } from "../../numbering/parseNumbering";
+/** This paragraph's place in a list. Null when it is not a list */
+export declare function listRefOf(node: PMNode): NumberingRef | null;
+/**
+ * The change that moves a list paragraph `delta` levels.
+ * Null when the paragraph is not in a list or already sits at the first or the last level.
+ * The indent buttons reuse this, so moving a level is the same edit however it is asked for.
+ */
+export declare function listLevelChange(numbering: Numbering, node: PMNode, delta: 1 | -1): ListChange | null;
+/** Moves a list item one level deeper, which is not the paragraph's own indent. What Tab does */
+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;
+/**
+ * Takes the selected paragraphs out of the list.
+ * Only the hanging indentation the marker sat in goes with it; an indentation the paragraph had
+ * of its own stays, putting it back where it was before it joined the list.
+ */
+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.
+ * 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.
+ */
+export declare function activeListKind(state: EditorState): ListKind | null;
+export declare const toggleNumberedList: Command;
+export declare const toggleBulletList: Command;
+/**
+ * Whether the selected paragraphs hold a list item, which is a fact about the document and so is
+ * answered whatever the lock says, as `activeListKind` beside it is.
+ * What a level shift would actually move is the level-shift command's own answer, the lock already
+ * part of it, and that is what a button runs on.
+ */
+export declare function isInList(state: EditorState): boolean;
+/**
+ * Pressing Enter in an empty list item does not open a new item.
+ *
+ * A deeper item comes up one level and stays in the list, and only an item already at the first
+ * level leaves it, so a nested list is climbed one press at a time (the same as Word).
+ * The paragraph itself stays where it is, which leaves the items after it in the list with their
+ * numbering slots untouched; they simply stop counting the item that was given up.
+ */
+export declare const leaveEmptyListItem: Command;

package/dist/editor/commands/listCommands.js

@@ -0,0 +1,140 @@
+// src/editor/commands/listCommands.ts
+import {
+  withLeftIndent,
+  withListNumbering
+} from "../../docx/paraProps.js";
+import { toParagraphFormat } from "../../model/format.js";
+import {
+  listFor,
+  listKindOf,
+  MAX_ILVL,
+  nextNumId
+} from "../../numbering/listTemplate.js";
+import { docxSchema } from "../../schema/index.js";
+import {
+  editableParagraphs,
+  editParagraphs,
+  paragraphPPr,
+  selectedParagraphs
+} from "../paragraphEdits.js";
+import {
+  canStartNewList,
+  documentNumbering
+} from "../plugins/numberingDecorations.js";
+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 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;
+  return indent ? { kind: "level", indent } : { kind: "keep" };
+}
+function listLevelChange(numbering, node, delta) {
+  const ref = listRefOf(node);
+  if (!ref) return null;
+  const ilvl = ref.ilvl + delta;
+  if (ilvl < 0 || ilvl > MAX_ILVL) return null;
+  const next = { numId: ref.numId, ilvl };
+  return { numbering: next, indent: indentForLevel(numbering, node, next) };
+}
+function levelShift(delta) {
+  return (state, dispatch) => {
+    const numbering = documentNumbering(state);
+    return changeParagraphs(
+      state,
+      dispatch,
+      (node) => listLevelChange(numbering, node, delta)
+    );
+  };
+}
+var increaseListLevel = levelShift(1);
+var decreaseListLevel = levelShift(-1);
+function usedNumIds(state, numbering) {
+  const used = new Set(numbering.lists.keys());
+  state.doc.descendants((node) => {
+    if (node.type !== docxSchema.nodes.paragraph) return true;
+    const ref = listRefOf(node);
+    if (ref) used.add(ref.numId);
+    return false;
+  });
+  return used;
+}
+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" }
+    }));
+  };
+}
+var removeFromList = (state, dispatch) => changeParagraphs(
+  state,
+  dispatch,
+  (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);
+  return level.format === "bullet" ? "bullet" : "numbered";
+}
+function activeListKind(state) {
+  const numbering = documentNumbering(state);
+  const kinds = editableParagraphs(state).map(({ node }) => {
+    const ref = listRefOf(node);
+    return ref === null ? null : kindOf(numbering, ref);
+  });
+  const first = kinds[0] ?? null;
+  return kinds.every((kind) => kind === first) ? first : null;
+}
+function toggleList(kind) {
+  return (state, dispatch) => activeListKind(state) === kind ? removeFromList(state, dispatch) : startList(kind)(state, dispatch);
+}
+var toggleNumberedList = toggleList("numbered");
+var toggleBulletList = toggleList("bullet");
+function isInList(state) {
+  return selectedParagraphs(state).some(
+    (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 leaveEmptyListItem = (state, dispatch) => {
+  const { empty, $from } = state.selection;
+  const paragraph = $from.parent;
+  if (!empty || paragraph.type !== docxSchema.nodes.paragraph) return false;
+  if (paragraph.content.size > 0) return false;
+  const ref = listRefOf(paragraph);
+  if (!ref) return false;
+  return ref.ilvl > 0 ? decreaseListLevel(state, dispatch) : leaveListAtLineStart(state, dispatch);
+};
+export {
+  activeListKind,
+  decreaseListLevel,
+  increaseListLevel,
+  isInList,
+  leaveEmptyListItem,
+  listLevelChange,
+  listRefOf,
+  removeFromList,
+  toggleBulletList,
+  toggleNumberedList
+};

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

@@ -0,0 +1,47 @@
+/**
+ * Adds or removes OOXML content locks. Multi-paragraph selections become separate controls, and
+ * unlocking preserves the control metadata while removing only its lock.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type Command, type EditorState } from "prosemirror-state";
+/**
+ * The lock state of the selection, which is the one answer the lock commands and the menus are
+ * built on.
+ *
+ * A selection holding both something to lock and a lock to lift is `mixed`, a state of its own
+ * rather than a pair of booleans a menu has to read a combination out of.
+ *
+ * A control the document locked against deletion alone leaves its contents open, so it reads as
+ * text to lock rather than as a lock in reach: lifting that one clause by itself is not a state
+ * this answer can name. The guard still refuses taking such a control away.
+ */
+export type SelectionLock = "none" | "lockable" | "locked" | "mixed";
+/** What locking and unlocking would do where the selection stands */
+export declare function selectionLock(state: EditorState): SelectionLock;
+/**
+ * Locks the selected text, as one content control per paragraph it runs through.
+ * A control of the same type replaces the one already worn rather than being laid over it, so
+ * shutting a control that already stands there is the very same step as wrapping a new one.
+ * 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 */
+export declare const unlockSelection: Command;
+/**
+ * Whether editing where the selection stands is shut.
+ * This is the same question the guard asks, so a menu built on it offers nothing that would
+ * then be refused: for a caret that means sitting inside a control rather than against its edge.
+ *
+ * A different question from `selectionLock`, deliberately: a caret against an edge lifts that
+ * control's lock, and is not itself shut by it.
+ */
+export declare function selectionTouchesLocked(state: EditorState): boolean;
+/**
+ * Whether the document holds any locked control at all, which is what registering a template turns
+ * on.
+ *
+ * Either clause counts: a control whose contents may not be edited, and one that may only not be
+ * taken away. This is a question about the document rather than about editing where the selection
+ * stands, and a document carrying the second kind is a document with a lock in it.
+ */
+export declare function documentHasLocked(doc: PMNode): boolean;

package/dist/editor/commands/lockCommands.js

@@ -0,0 +1,198 @@
+// src/editor/commands/lockCommands.ts
+import {
+  TextSelection
+} from "prosemirror-state";
+import { namesNothing, newControlId } from "../../docx/sdt.js";
+import { withContentLock } from "../../docx/sdtProps.js";
+import { docxSchema } from "../../schema/index.js";
+import {
+  carriesLock,
+  controlSpans,
+  isLockedCell,
+  rangeTouchesLocked,
+  selectionShut,
+  unlockAllowed
+} from "../../schema/locks.js";
+function lockedControlMark(id) {
+  return docxSchema.marks.sdt.create({
+    sdtPrefix: `<w:sdt><w:sdtPr><w:id w:val="${id}"/><w:lock w:val="sdtContentLocked"/></w:sdtPr>`,
+    contentsLocked: true,
+    deletionLocked: true
+  });
+}
+function isLocked(mark) {
+  return mark.attrs.contentsLocked === true;
+}
+function prefixOf(attrs) {
+  const prefix = attrs.sdtPrefix;
+  return typeof prefix === "string" ? prefix : null;
+}
+function withLock(mark, locked) {
+  const prefix = prefixOf(mark.attrs);
+  const next = prefix === null ? null : withContentLock(prefix, locked);
+  if (next === null) return null;
+  return mark.type.create({
+    ...mark.attrs,
+    sdtPrefix: next,
+    contentsLocked: locked,
+    deletionLocked: locked
+  });
+}
+function overlaps(a, b) {
+  return a.from < b.to && a.to > b.from;
+}
+function reaches(a, b) {
+  return a.from <= b.to && a.to >= b.from;
+}
+function stretchIn(block, reach) {
+  const from = Math.max(block.start, reach.from);
+  const to = Math.min(block.start + block.node.content.size, reach.to);
+  return from < to ? { from, to } : null;
+}
+function gapsIn(stretch, spans) {
+  const gaps = [];
+  let at = stretch.from;
+  for (const span of spans) {
+    const to = Math.min(span.from, stretch.to);
+    if (at < to) gaps.push({ from: at, to });
+    at = Math.max(at, span.to);
+  }
+  if (at < stretch.to) gaps.push({ from: at, to: stretch.to });
+  return gaps;
+}
+function takeover(met, stretch, open) {
+  const only = met.length === 1 ? met[0] : null;
+  const prefix = only && prefixOf(only.mark.attrs);
+  if (!only || isLocked(only.mark) || !prefix || !namesNothing(prefix)) {
+    return null;
+  }
+  const mark = open(stretch) ? withLock(only.mark, true) : null;
+  return mark ? {
+    from: Math.min(stretch.from, only.from),
+    to: Math.max(stretch.to, only.to),
+    mark
+  } : null;
+}
+function blockLockEdits(doc, block, spans, reach) {
+  const stretch = stretchIn(block, reach);
+  if (!stretch) return [];
+  const open = (at) => !rangeTouchesLocked(doc, at.from, at.to);
+  const met = spans.filter((span) => overlaps(span, stretch));
+  const taken = takeover(met, stretch, open);
+  if (taken) return [taken];
+  const shut = met.filter((span) => !isLocked(span.mark) && open(span)).flatMap((span) => {
+    const mark = withLock(span.mark, true);
+    return mark ? [{ from: span.from, to: span.to, mark }] : [];
+  });
+  const fresh = gapsIn(stretch, spans).filter(open).map((gap) => ({ ...gap, mark: lockedControlMark(newControlId()) }));
+  return [...shut, ...fresh];
+}
+function selectionLockDetail(state) {
+  const selection = state.selection;
+  const locking = !selection.empty && selection instanceof TextSelection;
+  const edits = [];
+  const spans = [];
+  const cells = /* @__PURE__ */ new Map();
+  for (const range of selection.ranges) {
+    const reach = { from: range.$from.pos, to: range.$to.pos };
+    state.doc.nodesBetween(reach.from, reach.to, (node, pos) => {
+      if (isLockedCell(node)) cells.set(pos, node);
+      if (!node.isTextblock) return true;
+      const block = { node, start: pos + 1 };
+      const controls = controlSpans(block);
+      for (const span of controls) {
+        if (isLocked(span.mark) && reaches(span, reach)) spans.push(span);
+      }
+      if (locking) {
+        edits.push(...blockLockEdits(state.doc, block, controls, reach));
+      }
+      return false;
+    });
+  }
+  const locked = {
+    spans,
+    cells: Array.from(cells, ([pos, node]) => ({ pos, node }))
+  };
+  const anyLocked = spans.length > 0 || locked.cells.length > 0;
+  if (edits.length === 0) {
+    return anyLocked ? { kind: "locked", ...locked } : { kind: "none" };
+  }
+  return anyLocked ? { kind: "mixed", edits, ...locked } : { kind: "lockable", edits };
+}
+function selectionLock(state) {
+  return selectionLockDetail(state).kind;
+}
+function lockEditsOf(lock) {
+  switch (lock.kind) {
+    case "lockable":
+    case "mixed":
+      return lock.edits;
+    case "none":
+    case "locked":
+      return [];
+  }
+}
+var NOTHING_LOCKED = { spans: [], cells: [] };
+function lockedOf(lock) {
+  switch (lock.kind) {
+    case "locked":
+    case "mixed":
+      return lock;
+    case "none":
+    case "lockable":
+      return NOTHING_LOCKED;
+  }
+}
+var lockSelection = (state, dispatch) => {
+  const edits = lockEditsOf(selectionLockDetail(state));
+  if (edits.length === 0) return false;
+  if (dispatch) {
+    const tr = state.tr;
+    for (const edit of edits) tr.addMark(edit.from, edit.to, edit.mark);
+    dispatch(tr);
+  }
+  return true;
+};
+function unlockCell(tr, cell) {
+  const prefix = prefixOf(cell.node.attrs);
+  tr.setNodeMarkup(cell.pos, null, {
+    ...cell.node.attrs,
+    sdtPrefix: prefix === null ? null : withContentLock(prefix, false),
+    sdtContentsLocked: false,
+    sdtDeletionLocked: false
+  });
+}
+var unlockSelection = (state, dispatch) => {
+  const { spans, cells } = lockedOf(selectionLockDetail(state));
+  if (spans.length === 0 && cells.length === 0) return false;
+  if (dispatch) {
+    const tr = state.tr.setMeta(unlockAllowed, true);
+    for (const span of spans) {
+      const opened = withLock(span.mark, false);
+      if (opened) tr.addMark(span.from, span.to, opened);
+      else tr.removeMark(span.from, span.to, span.mark);
+    }
+    for (const cell of cells) unlockCell(tr, cell);
+    dispatch(tr);
+  }
+  return true;
+};
+function selectionTouchesLocked(state) {
+  return selectionShut(state.selection, state.doc);
+}
+function documentHasLocked(doc) {
+  let found = false;
+  doc.descendants((node) => {
+    if (found) return false;
+    if (carriesLock(node)) found = true;
+    return !found;
+  });
+  return found;
+}
+export {
+  documentHasLocked,
+  lockSelection,
+  selectionLock,
+  selectionTouchesLocked,
+  unlockSelection
+};

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

@@ -0,0 +1,12 @@
+/** Document-level readers for imported footnotes and endnotes. */
+import type { EditorState } from "prosemirror-state";
+import type { NoteKind } from "../../docx/notes";
+export interface DocumentNote {
+    kind: NoteKind;
+    id: string;
+    label: string;
+    text: string;
+    referencePos: number;
+}
+/** The distinct notes referenced by the main document story, in first-reference order. */
+export declare function documentNotes(state: EditorState): readonly DocumentNote[];

package/dist/editor/commands/noteQueries.js

@@ -0,0 +1,29 @@
+// src/editor/commands/noteQueries.ts
+function stringAttr(value) {
+  return typeof value === "string" ? value : null;
+}
+function documentNotes(state) {
+  const notes = [];
+  const seen = /* @__PURE__ */ new Set();
+  state.doc.descendants((node, pos) => {
+    if (node.type.name !== "noteReference") return true;
+    const id = stringAttr(node.attrs.id);
+    if (id === null) return true;
+    const kind = node.attrs.kind === "endnote" ? "endnote" : "footnote";
+    const key = `${kind}:${id}`;
+    if (seen.has(key)) return true;
+    seen.add(key);
+    notes.push({
+      kind,
+      id,
+      label: stringAttr(node.attrs.label) ?? "?",
+      text: stringAttr(node.attrs.text) ?? "",
+      referencePos: pos
+    });
+    return true;
+  });
+  return notes;
+}
+export {
+  documentNotes
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Paragraph formatting commands: the alignment, and the style the paragraph points at.
+ *
+ * Alignment swaps the `w:jc` of the selected paragraphs and leaves the rest of the paragraph
+ * formatting untouched.
+ * Applying a style writes nothing but the `w:pStyle`, the same as Word: the values the style
+ * lays down are inherited rather than copied, so the direct formatting already written keeps
+ * beating them.
+ * All XML handling belongs to `docx/paraProps`; this file only calls those functions.
+ */
+import type { Command, EditorState } from "prosemirror-state";
+import { type ParagraphAlign } from "../../model/format";
+/**
+ * Sets the alignment of the selected paragraphs.
+ * Exactly one alignment is always on, so there is no command to clear it (the same as Word).
+ */
+export declare function setParagraphAlign(align: ParagraphAlign): Command;
+/**
+ * Whether there is a paragraph to align at all, which is what the alignment menu is drawn from.
+ *
+ * The four alignments are one choice, so no single one of them answers for the menu: the one the
+ * selection already wears would report that it has nothing to do. What settles it is whether the
+ * lock leaves any of the selected paragraphs open (`editor/paragraphEdits`), the same question
+ * `canSetLineSpacing` asks for the menu beside it.
+ */
+export declare function canSetParagraphAlign(state: EditorState): boolean;
+/** The alignment of the selected paragraphs */
+export type ActiveParagraphAlign = 
+/** They are all drawn with the same one */
+{
+    kind: "shared";
+    align: ParagraphAlign;
+}
+/** They are drawn with several different ones, or the selection holds no paragraph at all */
+ | {
+    kind: "mixed";
+};
+export declare function activeParagraphAlign(state: EditorState): ActiveParagraphAlign;
+/**
+ * Points the selected paragraphs at one of the styles the document defines.
+ * A null id takes the `w:pStyle` away, which is how a paragraph wears the default style.
+ */
+export declare function setParagraphStyle(styleId: string | null): Command;
+/** The style the selected paragraphs point at */
+export type ActiveParagraphStyle = 
+/** They all point at the same one. A null id is a paragraph wearing the default style */
+{
+    kind: "shared";
+    styleId: string | null;
+}
+/** They point at several different ones */
+ | {
+    kind: "mixed";
+}
+/** The selection holds no paragraph at all, so there is no style to show or to change */
+ | {
+    kind: "none";
+};
+export declare function activeParagraphStyle(state: EditorState): ActiveParagraphStyle;