@portone/docx-editor 0.2.1 → 0.3.0

package/dist/editor/clipboard/inlineFormatting.js

@@ -1,5 +1,7 @@
 // src/editor/clipboard/inlineFormatting.ts
-import { editRunProps } from "../../docx/runProps.js";
+import { rPrOf } from "../../docx/formatting.js";
+import { readRunProps } from "../../docx/runProps.js";
+import { HALF_POINTS_PER_PT, ST_HpsMeasure } from "../../ooxml/simpleTypes.js";
 import { docxSchema } from "../../schema/index.js";
 import { editorClassNames } from "../../styles/classNames.js";
 var IGNORED_TAGS = /* @__PURE__ */ new Set([
@@ -76,8 +78,8 @@ function fontSizePt(value) {
   const amount = Number.parseFloat(match[1] ?? "");
   if (!Number.isFinite(amount) || amount <= 0) return null;
   const points = match[2]?.toLowerCase() === "px" ? amount * 0.75 : amount;
-  const rounded = Math.round(points * 2) / 2;
-  return rounded > 0 && rounded <= 819 ? rounded : null;
+  const half = Math.round(points * HALF_POINTS_PER_PT);
+  return ST_HpsMeasure.format(half) === null ? null : half / HALF_POINTS_PER_PT;
 }
 function legacyFontSize(value) {
   const sizes = [8, 10, 12, 14, 18, 24, 36];
@@ -150,34 +152,21 @@ function contextFor(parent, element, readElementStyle = true) {
 function withInlineStyle(context, style) {
   return { ...context, style: { ...context.style, ...style } };
 }
+function settingsOf(style) {
+  const settings = {};
+  if (style.bold) settings.bold = true;
+  if (style.italic) settings.italic = true;
+  if (style.underline) settings.underline = "single";
+  if (style.strike) settings.strike = true;
+  if (style.fontSizePt !== void 0) settings.fontSizePt = style.fontSizePt;
+  if (style.fontFamily !== void 0) settings.fontFamily = style.fontFamily;
+  if (style.color !== void 0) settings.color = style.color;
+  if (style.background !== void 0) settings.background = style.background;
+  return settings;
+}
 function runMark(style) {
-  const edits = [];
-  if (style.bold) edits.push({ kind: "toggle", toggle: "bold", on: true });
-  if (style.italic) edits.push({ kind: "toggle", toggle: "italic", on: true });
-  if (style.underline) {
-    edits.push({ kind: "toggle", toggle: "underline", on: true });
-  }
-  if (style.strike) edits.push({ kind: "toggle", toggle: "strike", on: true });
-  if (style.fontSizePt !== void 0) {
-    edits.push({ kind: "fontSize", pt: style.fontSizePt });
-  }
-  if (style.fontFamily !== void 0) {
-    edits.push({ kind: "fontFamily", name: style.fontFamily });
-  }
-  if (style.color !== void 0)
-    edits.push({ kind: "color", hex: style.color });
-  if (style.background !== void 0) {
-    edits.push({ kind: "background", hex: style.background });
-  }
-  let props = {
-    rPr: null,
-    format: null
-  };
-  for (const edit of edits) {
-    const next = editRunProps(props, null, edit);
-    if (next) props = next;
-  }
-  return props.rPr === null ? null : docxSchema.marks.run.create({ rPr: props.rPr, format: props.format });
+  const rPr = rPrOf(settingsOf(style));
+  return rPr === null ? null : docxSchema.marks.run.create({ rPr, format: readRunProps(rPr) });
 }
 function marksFor(context) {
   const marks = [];

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

@@ -1,10 +1,14 @@
 /** Edits Word comments through their range markers and reference nodes. */
 import { type Command, type EditorState } from "prosemirror-state";
 import type { NewComment } from "./model";
-/** Whether a non-empty selection in one paragraph can receive a comment. */
-export declare function canAddComment(state: EditorState): boolean;
 /** Adds a plain-text comment to the current text selection. */
 export declare function addComment(comment: NewComment): Command;
+/**
+ * Whether a non-empty selection in one paragraph can receive a comment.
+ * This is the command itself asked without a dispatch, over a comment standing in for the one the
+ * user would write, so the button and the click cannot answer differently.
+ */
+export declare function canAddComment(state: EditorState): boolean;
 /** Replaces the plain-text body of one comment, retaining its author and anchor. */
 export declare function updateComment(id: string, text: string): Command;
 /** Marks a comment thread resolved or open without deleting it. */

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

@@ -4,11 +4,11 @@ import {
 } from "prosemirror-state";
 import { commentParaId } from "../../../docx/comments.js";
 import { docxSchema } from "../../../schema/index.js";
-import { transactionAllowed } from "../../../schema/guards.js";
+import { guardedCommand } from "../../../schema/guards.js";
 import {
   reservedCommentIds,
   reservedCommentParaIds
-} from "../../plugins/commentReservations.js";
+} from "../../editorDocument.js";
 import { documentComments, repliesAttr, stringAttr } from "./reading.js";
 function validCommentSelection(state) {
   const { selection } = state;
@@ -113,27 +113,21 @@ function addCommentTransaction(state, comment) {
     null,
     startMarks
   );
-  const transaction = state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
-  return transactionAllowed(transaction, state) ? transaction : null;
+  return state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
+}
+function addComment(comment) {
+  return guardedCommand((state) => addCommentTransaction(state, comment));
 }
 function canAddComment(state) {
-  return addCommentTransaction(state, {
+  return addComment({
     text: "comment",
     author: "Author",
     date: "1970-01-01T00:00:00.000Z"
-  }) !== null;
-}
-function addComment(comment) {
-  return (state, dispatch) => {
-    const transaction = addCommentTransaction(state, comment);
-    if (!transaction) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+  })(state);
 }
 function updateComment(id, text) {
-  return (state, dispatch) => {
-    if (text.trim().length === 0) return false;
+  return guardedCommand((state) => {
+    if (text.trim().length === 0) return null;
     let transaction = state.tr;
     let changed = false;
     state.doc.descendants((node, pos) => {
@@ -148,13 +142,11 @@ function updateComment(id, text) {
       }
       return true;
     });
-    if (!changed || !transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changed ? transaction : null;
+  });
 }
 function updateReference(id, change) {
-  return (state, dispatch) => {
+  return guardedCommand((state) => {
     let transaction = state.tr;
     let changed = false;
     state.doc.descendants((node, pos) => {
@@ -168,10 +160,8 @@ function updateReference(id, change) {
       }
       return false;
     });
-    if (!changed || !transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changed ? transaction : null;
+  });
 }
 function setCommentResolved(id, resolved) {
   return (state, dispatch) => updateReference(id, (node) => {
@@ -261,7 +251,7 @@ function removeCommentReply(commentId, replyId) {
   });
 }
 function removeComment(id) {
-  return (state, dispatch) => {
+  return guardedCommand((state) => {
     const positions = [];
     state.doc.descendants((node, pos) => {
       if ((node.type.name === "commentStart" || node.type.name === "commentEnd" || node.type.name === "commentReference") && stringAttr(node.attrs.id) === id) {
@@ -269,15 +259,13 @@ function removeComment(id) {
       }
       return true;
     });
-    if (positions.length === 0) return false;
+    if (positions.length === 0) return null;
     const transaction = state.tr;
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    if (!transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return transaction;
+  });
 }
 function selectComment(id) {
   return (state, dispatch) => {

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

@@ -0,0 +1,15 @@
+/** Document-level readers for whether the document as it stands can be written back. */
+import type { EditorState } from "prosemirror-state";
+import { type ExportProblem } from "../../docx/invariants";
+export type { ExportProblem } from "../../docx/invariants";
+/**
+ * Every reason writing the document back would be refused, in the order `exportDocx` would raise
+ * them, each with the code and message the refusal would carry and the position in the document
+ * where there is one. Empty when the file would be written.
+ *
+ * A state built without an opened document has no file to write back into, so nothing about it
+ * can be refused and it reports no problem.
+ */
+export declare function documentExportProblems(state: EditorState): readonly ExportProblem[];
+/** Whether the document as it stands can be written back, which is what an export control is drawn from */
+export declare function canExport(state: EditorState): boolean;

package/dist/editor/commands/exportQueries.js

@@ -0,0 +1,14 @@
+// src/editor/commands/exportQueries.ts
+import { exportProblems } from "../../docx/invariants.js";
+import { documentOf } from "../editorDocument.js";
+function documentExportProblems(state) {
+  const { session } = documentOf(state);
+  return session === null ? [] : exportProblems(state.doc, session);
+}
+function canExport(state) {
+  return documentExportProblems(state).length === 0;
+}
+export {
+  canExport,
+  documentExportProblems
+};

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

@@ -0,0 +1,12 @@
+/** Document-level reader for what the open document holds that the editor cannot model. */
+import type { EditorState } from "prosemirror-state";
+import { type FidelityNote } from "../../docx/fidelity";
+export type { FidelityCode, FidelityNote, FidelitySeverity, } from "../../docx/fidelity";
+/**
+ * What the document standing in the editor hides, stands a placeholder in front of, or approximates.
+ *
+ * The notes are read off the document as it is now, so a note goes away as soon as an edit removes
+ * what it was about. `part` is null: an editor state carries the document and not the file it came
+ * from, and `importDocx` is where a note can name the part it belongs to.
+ */
+export declare function documentFidelity(state: EditorState): readonly FidelityNote[];

package/dist/editor/commands/fidelityQueries.js

@@ -0,0 +1,8 @@
+// src/editor/commands/fidelityQueries.ts
+import { fidelityNotesOf } from "../../docx/fidelity.js";
+function documentFidelity(state) {
+  return fidelityNotesOf(state.doc, null);
+}
+export {
+  documentFidelity
+};

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,103 @@
+// 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 {
+  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);
+  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";
 /**