@portone/docx-editor 0.2.1 → 0.3.0

package/dist/docx/pageGeometry.js

@@ -1,8 +1,15 @@
 // src/docx/pageGeometry.ts
-import { toNumber, wAttr } from "../ooxml/units.js";
+import {
+  ST_SignedTwipsMeasure,
+  ST_TwipsMeasure,
+  TWIPS_PER_INCH,
+  TWIPS_PER_PT
+} from "../ooxml/simpleTypes.js";
+import { wAttr } from "../ooxml/units.js";
 import { childByLocalName } from "../ooxml/xml.js";
-var TWIPS_PER_CM = 1440 / 2.54;
-var PX_PER_TWIP = 96 / 1440;
+var TWIPS_PER_CM = TWIPS_PER_INCH / 2.54;
+var PX_PER_PT = 96 / 72;
+var PX_PER_TWIP = PX_PER_PT / TWIPS_PER_PT;
 function cm(value) {
   return Math.round(value * TWIPS_PER_CM);
 }
@@ -34,13 +41,14 @@ function readPageGeometry(sectPr) {
   if (!sectPr) return A4_PORTRAIT;
   const pgSz = childByLocalName(sectPr, "pgSz");
   const pgMar = childByLocalName(sectPr, "pgMar");
-  const width = pgSz ? readSize(toNumber(wAttr(pgSz, "w"))) : null;
-  const height = pgSz ? readSize(toNumber(wAttr(pgSz, "h"))) : null;
+  const width = pgSz ? readSize(ST_TwipsMeasure.parse(wAttr(pgSz, "w"))) : null;
+  const height = pgSz ? readSize(ST_TwipsMeasure.parse(wAttr(pgSz, "h"))) : null;
   const readable = width !== null && height !== null;
-  const marginLeft = pgMar ? toNumber(wAttr(pgMar, "left")) : null;
-  const marginRight = pgMar ? toNumber(wAttr(pgMar, "right")) : null;
-  const marginTop = pgMar ? toNumber(wAttr(pgMar, "top")) : null;
-  const marginBottom = pgMar ? toNumber(wAttr(pgMar, "bottom")) : null;
+  const margin = (side) => pgMar ? ST_SignedTwipsMeasure.parse(wAttr(pgMar, side)) : null;
+  const marginLeft = margin("left");
+  const marginRight = margin("right");
+  const marginTop = margin("top");
+  const marginBottom = margin("bottom");
   const geometry = {
     widthTwips: readable ? width : A4_PORTRAIT.widthTwips,
     heightTwips: readable ? height : A4_PORTRAIT.heightTwips,
@@ -79,6 +87,7 @@ function firstSectPrIn(root) {
 export {
   A4_BODY_WIDTH,
   A4_PORTRAIT,
+  PX_PER_PT,
   bodyHeightTwips,
   bodyWidth,
   bodyWidthTwips,

package/dist/docx/paraProps.d.ts

@@ -5,14 +5,12 @@
  * When one paragraph is changed, the formatting we do not touch, such as tab stops and borders,
  * must stay as the original text wrote it. So we never rebuild the fragment; we change it one child
  * at a time, and within a child one attribute at a time.
- * The fragment we operated on is read back with the parser used when opening the document to build
- * the display values, and the style the paragraph points at is layered in the same order as it was
- * then. That way a changed paragraph's display values are the same as they would be after saving
- * and reopening.
+ * What the edited fragment is drawn with is not decided here: the caller hands the fragment to the
+ * resolver (`formatting/resolve`), the same one opening the document uses, so a changed paragraph's
+ * display values are the same as they would be after saving and reopening.
  */
-import type { LineSpacing, NumberingRef, ParagraphAlign, ParagraphFormat, RunFormat } from "../model/format";
+import type { LineSpacing, NumberingRef, ParagraphAlign } from "../model/format";
 import type { LevelIndent } from "../numbering/parseNumbering";
-import { type StyleTable } from "./formatting";
 /** What to do with the indents */
 export type IndentChange = 
 /** Leaves the indents the paragraph wrote down as they are */
@@ -33,32 +31,22 @@ export interface ListChange {
     numbering: NumberingRef | null;
     indent: IndentChange;
 }
-/** The paragraph formatting we operated on, and the display values read back out of it */
+/** The paragraph formatting we operated on. A null `pPr` is a fragment with nothing left in it */
 export interface ParagraphProps {
     pPr: string | null;
-    format: ParagraphFormat | null;
-    /** The character formatting the style the paragraph now wears lays down (`styleRun` in `schema`) */
-    styleRun: RunFormat | null;
 }
-/**
- * Reads the fragment we operated on back along the same path used when opening the document.
- *
- * The values of the style the paragraph wears are laid down underneath (the same order as import),
- * which for a paragraph pointing at no style of its own is the document's default paragraph style.
- */
-export declare function readParagraphProps(pPr: string | null, styles?: StyleTable, defaultStyleId?: string | null): ParagraphFormat | null;
-export declare function withListNumbering(pPr: string | null, change: ListChange, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withListNumbering(pPr: string | null, change: ListChange): ParagraphProps | null;
 /**
  * The result of moving the paragraph's own left indent to `leftTwips`.
  * Everything else the indent recorded - the hanging or first-line indent, the right indent -
  * stays as it was.
  */
-export declare function withLeftIndent(pPr: string | null, leftTwips: number, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withLeftIndent(pPr: string | null, leftTwips: number): ParagraphProps | null;
 /**
  * The result of changing the line spacing. The space above and below the paragraph is left as it was.
  * `auto` states the multiple in 240ths of a line; the other rules pin the height down in twips.
  */
-export declare function withLineSpacing(pPr: string | null, spacing: LineSpacing, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withLineSpacing(pPr: string | null, spacing: LineSpacing): ParagraphProps | null;
 /**
  * The result of pointing the paragraph at a named style.
  * A null id takes the pStyle away, which is how the default style is worn.
@@ -66,9 +54,9 @@ export declare function withLineSpacing(pPr: string | null, spacing: LineSpacing
  * Nothing else in the fragment moves: as in Word, a style is applied by naming it and not by
  * copying its values into the paragraph, so the direct formatting written here keeps beating it.
  */
-export declare function withParagraphStyle(pPr: string | null, styleId: string | null, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withParagraphStyle(pPr: string | null, styleId: string | null): ParagraphProps | null;
 /**
  * The result of changing the paragraph alignment.
  * One alignment is always on, so we provide no way to withdraw the setting (the same as Word).
  */
-export declare function withParagraphAlign(pPr: string | null, align: ParagraphAlign, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withParagraphAlign(pPr: string | null, align: ParagraphAlign): ParagraphProps | null;

package/dist/docx/paraProps.js

@@ -1,26 +1,23 @@
 // src/docx/paraProps.ts
 import {
-  attrPairs,
   elementXml,
+  wAttrValue,
   withoutAttrs
 } from "../ooxml/element.js";
 import { wName } from "../ooxml/names.js";
 import { setAttr } from "../ooxml/precedence.js";
-import { childByLocalName, localPart } from "../ooxml/xml.js";
 import {
-  layerParagraphFormat,
-  layerRunFormat,
-  NO_STYLES,
-  paragraphStyleFormat,
-  readParagraphFormat
-} from "./formatting.js";
-import {
-  P_PR_ORDER,
+  childElement,
   parseProps,
-  parsePropsXml,
   renderProps,
-  setPropsChild
-} from "./propsXml.js";
+  setChild
+} from "../ooxml/props.js";
+import {
+  ST_DecimalNumber,
+  ST_SignedTwipsMeasure,
+  TWIPS_PER_PT
+} from "../ooxml/simpleTypes.js";
+import { LINE_UNITS_PER_LINE } from "./formatting.js";
 var LEFT_IND_ATTRS = ["left", "start", "leftChars", "startChars"];
 var LEFT_TWIPS_IND_ATTRS = ["left", "start"];
 var HANGING_IND_ATTRS = ["hanging", "hangingChars"];
@@ -29,15 +26,6 @@ var FIRST_LINE_IND_ATTRS = [
   "firstLine",
   "firstLineChars"
 ];
-function readParagraphProps(pPr, styles = NO_STYLES, defaultStyleId = null) {
-  const direct = pPr === null ? null : readParagraphFormat(parsePropsXml(pPr));
-  const style = paragraphStyleFormat(pPr, styles, defaultStyleId);
-  return layerParagraphFormat(style?.paragraph ?? {}, direct);
-}
-function readParagraphStyleRun(pPr, styles = NO_STYLES, defaultStyleId = null) {
-  const style = paragraphStyleFormat(pPr, styles, defaultStyleId);
-  return layerRunFormat(style?.run ?? {}, null);
-}
 function numPrXml(ref) {
   if (!ref) return null;
   return elementXml(
@@ -66,91 +54,75 @@ function indXml(attrs) {
 function nextIndXml(ind, change) {
   if (change.kind === "keep") return void 0;
   if (change.kind === "clearHanging") {
-    return indXml(withoutAttrs(attrPairs(ind), HANGING_IND_ATTRS));
+    return indXml(withoutAttrs(ind, HANGING_IND_ATTRS));
   }
   const dropped = [...LEFT_IND_ATTRS, ...FIRST_LINE_IND_ATTRS];
   return indXml([
     ...levelIndAttrs(change.indent),
-    ...withoutAttrs(attrPairs(ind), dropped)
+    ...withoutAttrs(ind, dropped)
   ]);
 }
-function leftIndAttrs(ind, leftTwips) {
-  const original = attrPairs(ind);
-  const slot = original.find(
-    ([name]) => LEFT_TWIPS_IND_ATTRS.includes(localPart(name))
-  )?.[0];
+function leftIndAttrs(original, leftTwips) {
+  const slot = LEFT_TWIPS_IND_ATTRS.find(
+    (name) => wAttrValue(original, name) !== null
+  );
   const written = leftTwips > 0 ? `${leftTwips}` : null;
   const kept = withoutAttrs(
     original,
-    LEFT_IND_ATTRS.filter(
-      (name) => slot === void 0 || name !== localPart(slot)
-    )
+    LEFT_IND_ATTRS.filter((name) => name !== slot)
   );
-  if (slot !== void 0) return setAttr(kept, "ind", localPart(slot), written);
+  if (slot !== void 0) return setAttr(kept, "ind", slot, written);
   return written === null ? kept : [[wName("left"), written], ...kept];
 }
 var EMPTY_P_PR = { tag: "w:pPr", attrs: null, children: [] };
-function editParagraphProps(pPr, styles, defaultStyleId, plan) {
+function editParagraphProps(pPr, plan) {
   const props = pPr === null ? EMPTY_P_PR : parseProps(pPr);
-  const element = pPr === null ? null : parsePropsXml(pPr);
-  if (!props || pPr !== null && !element) return null;
+  if (!props) return null;
+  const edits = plan(props);
+  if (!edits) return null;
   const rendered = renderProps(
-    plan(element).reduce(
-      (kept, [name, xml]) => setPropsChild(kept, name, xml, P_PR_ORDER),
-      props
-    )
+    edits.reduce((kept, [name, xml]) => setChild(kept, name, xml), props)
   );
-  const next = rendered === "" ? null : rendered;
-  return {
-    pPr: next,
-    format: readParagraphProps(next, styles, defaultStyleId),
-    styleRun: readParagraphStyleRun(next, styles, defaultStyleId)
-  };
+  return { pPr: rendered === "" ? null : rendered };
 }
-function withListNumbering(pPr, change, styles = NO_STYLES, defaultStyleId = null) {
-  return editParagraphProps(pPr, styles, defaultStyleId, (element) => {
-    const ind = nextIndXml(
-      element ? childByLocalName(element, "ind") : null,
-      change.indent
-    );
+function withListNumbering(pPr, change) {
+  return editParagraphProps(pPr, (props) => {
+    const current = childElement(props, "ind");
+    if (!current) return null;
+    const ind = nextIndXml(current.attrs, change.indent);
     const numPr = ["numPr", numPrXml(change.numbering)];
     return ind === void 0 ? [numPr] : [numPr, ["ind", ind]];
   });
 }
-function withLeftIndent(pPr, leftTwips, styles = NO_STYLES, defaultStyleId = null) {
-  return editParagraphProps(pPr, styles, defaultStyleId, (element) => {
-    const ind = element ? childByLocalName(element, "ind") : null;
-    return [["ind", indXml(leftIndAttrs(ind, leftTwips))]];
+function withLeftIndent(pPr, leftTwips) {
+  return editParagraphProps(pPr, (props) => {
+    const ind = childElement(props, "ind");
+    if (!ind) return null;
+    return [["ind", indXml(leftIndAttrs(ind.attrs, leftTwips))]];
   });
 }
 function spacingAttrs(spacing, edits) {
-  const changed = attrPairs(spacing).map(
-    ([name, value]) => [
-      name,
-      edits.find(([edited]) => edited === localPart(name))?.[1] ?? value
-    ]
-  );
   return edits.reduce(
     (attrs, [name, value]) => setAttr(attrs, "spacing", name, value),
-    changed
+    spacing
   );
 }
-function withLineSpacing(pPr, spacing, styles = NO_STYLES, defaultStyleId = null) {
-  const line = spacing.rule === "auto" ? Math.round(spacing.lines * 240) : Math.round(spacing.pt * 20);
-  return editParagraphProps(pPr, styles, defaultStyleId, (element) => {
-    const current = element ? childByLocalName(element, "spacing") : null;
-    const attrs = spacingAttrs(current, [
-      ["line", `${line}`],
+function withLineSpacing(pPr, spacing) {
+  const line = spacing.rule === "auto" ? ST_DecimalNumber.format(Math.round(spacing.lines * LINE_UNITS_PER_LINE)) : ST_SignedTwipsMeasure.format(Math.round(spacing.pt * TWIPS_PER_PT));
+  if (line === null) return null;
+  return editParagraphProps(pPr, (props) => {
+    const current = childElement(props, "spacing");
+    if (!current) return null;
+    const attrs = spacingAttrs(current.attrs, [
+      ["line", line],
       ["lineRule", spacing.rule]
     ]);
     return [["spacing", elementXml(wName("spacing"), attrs)]];
   });
 }
-function withParagraphStyle(pPr, styleId, styles = NO_STYLES, defaultStyleId = null) {
+function withParagraphStyle(pPr, styleId) {
   const pStyle = styleId === null ? null : elementXml(wName("pStyle"), [[wName("val"), styleId]]);
-  return editParagraphProps(pPr, styles, defaultStyleId, () => [
-    ["pStyle", pStyle]
-  ]);
+  return editParagraphProps(pPr, () => [["pStyle", pStyle]]);
 }
 var JC_BY_ALIGN = {
   left: "left",
@@ -158,12 +130,11 @@ var JC_BY_ALIGN = {
   right: "right",
   justify: "both"
 };
-function withParagraphAlign(pPr, align, styles = NO_STYLES, defaultStyleId = null) {
+function withParagraphAlign(pPr, align) {
   const jc = elementXml(wName("jc"), [[wName("val"), JC_BY_ALIGN[align]]]);
-  return editParagraphProps(pPr, styles, defaultStyleId, () => [["jc", jc]]);
+  return editParagraphProps(pPr, () => [["jc", jc]]);
 }
 export {
-  readParagraphProps,
   withLeftIndent,
   withLineSpacing,
   withListNumbering,

package/dist/docx/partPlan.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The contract every part an export writes beside the body is written under.
+ *
+ * A planner answers with the parts it rewrites, keyed by path, and declares what a part it adds
+ * needs through the two writers the context carries: a relationship from the main part and a
+ * content type. Those two parts are written once at the end from everything every planner asked
+ * for, so no planner writes either of them itself and none can write over what another declared.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ContentTypeWriter } from "./packageParts";
+import { type RelationshipWriter } from "./relationships";
+import type { SessionStore } from "./session";
+export interface PartPlanContext {
+    readonly relationships: RelationshipWriter;
+    readonly contentTypes: ContentTypeWriter;
+}
+export interface PartPlanner {
+    readonly name: string;
+    /** The parts to write, keyed by path, and null when the document gives this planner nothing to write */
+    plan(doc: PMNode, session: SessionStore, context: PartPlanContext): ReadonlyMap<string, Uint8Array> | null;
+}
+/**
+ * Every part the planners write, folded into one map in planner order.
+ *
+ * The body and context-owned parts are reserved. Earlier writes include media planned before
+ * the body, so no later planner can overwrite those bytes either. Part names are compared
+ * without regard to case, as package part names are.
+ */
+export declare function runPartPlanners(planners: readonly PartPlanner[], doc: PMNode, session: SessionStore, context: PartPlanContext, prior?: ReadonlyMap<string, Uint8Array>): Map<string, Uint8Array>;
+/**
+ * Every rewritten XML part has to read back as XML, and a refusal names the part.
+ *
+ * The parts are spliced as text, so this is where a splice that cut in the wrong place shows up:
+ * before the package is repacked rather than when somebody opens it.
+ */
+export declare function assertPartsParse(replacements: ReadonlyMap<string, Uint8Array>, contentTypes?: Uint8Array): void;

package/dist/docx/partPlan.js

@@ -0,0 +1,59 @@
+// src/docx/partPlan.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { decodeUtf8, parseXml } from "../ooxml/xml.js";
+import {
+  CONTENT_TYPES_PATH,
+  declaredXmlParts
+} from "./packageParts.js";
+import { relsPathOf } from "./relationships.js";
+function runPartPlanners(planners, doc, session, context, prior = /* @__PURE__ */ new Map()) {
+  const owned = new Set(
+    [
+      CONTENT_TYPES_PATH,
+      relsPathOf(session.mainPartPath),
+      session.mainPartPath
+    ].map((path) => path.toLowerCase())
+  );
+  const parts = new Map(prior);
+  const written = new Set(
+    Array.from(prior.keys(), (path) => path.toLowerCase())
+  );
+  for (const planner of planners) {
+    for (const [path, bytes] of planner.plan(doc, session, context) ?? []) {
+      if (owned.has(path.toLowerCase())) {
+        throw new Error(
+          `the ${planner.name} planner wrote ${path}, which another export writer owns`
+        );
+      }
+      if (written.has(path.toLowerCase())) {
+        throw new Error(
+          `the ${planner.name} planner wrote ${path}, which an earlier writer wrote already`
+        );
+      }
+      parts.set(path, bytes);
+      written.add(path.toLowerCase());
+    }
+  }
+  return parts;
+}
+var XML_PART = /\.(?:xml|rels)$/i;
+function assertPartsParse(replacements, contentTypes) {
+  const paths = [...replacements.keys()];
+  const declared = contentTypes && paths.some((path) => !XML_PART.test(path)) ? declaredXmlParts(contentTypes, paths) : /* @__PURE__ */ new Set();
+  for (const [path, bytes] of replacements) {
+    if (!XML_PART.test(path) && !declared.has(path)) continue;
+    try {
+      parseXml(decodeUtf8(bytes).text);
+    } catch (cause) {
+      throw new DocxExportError(
+        "malformed-xml",
+        `${path} as written could not be parsed`,
+        { cause }
+      );
+    }
+  }
+}
+export {
+  assertPartsParse,
+  runPartPlanners
+};

package/dist/docx/protectionPolicy.d.ts

@@ -0,0 +1,127 @@
+/**
+ * What a protection level lets a change rewrite, as one value every side of the package reads.
+ *
+ * A level says three things: which parts of the package a change may write, what an entry in one
+ * of those parts may look like, and how the story reads once the markup the level is about is
+ * taken out of it. The part planners write those parts and the verifier judges them, and each
+ * carried its own copy of the first two with nothing but a test holding them together. Declaring
+ * them once means a part the writer starts adding is a part the verifier already knows.
+ *
+ * A level with no policy registered is one no file is judged under: `protectionPolicyFor` answers
+ * undefined, and a caller holding the level alone has nothing to run.
+ */
+import { type XmlParser } from "../ooxml/xml";
+import type { EditableComments, EditingProtection } from "../schema/protection";
+import { type DocxBytes } from "./importDocx";
+import type { SessionStore } from "./session";
+import { type Story } from "./storyProjection";
+/** One entry of a story part: the element read out of it, and its text for the byte-for-byte case */
+export interface StoryEntry {
+    el: Element;
+    xml: string;
+}
+/**
+ * How a part's entries are read.
+ *
+ * `arrived` is the reference a submission is held against rather than something to judge, so it
+ * takes what it can read and passes over the rest, leaving an entry standing on something
+ * unreadable to be judged as one that appeared. `submitted` is what is judged.
+ */
+export type EntryReading = "arrived" | "submitted";
+/** What a judgement may be told about the reader beyond the two documents */
+export interface PolicyOptions {
+    editableComments: EditableComments;
+}
+/** What a judgement over two files may be told beyond that */
+export interface VerifyOptions extends PolicyOptions {
+    xmlParser?: XmlParser;
+}
+/** One package part a protection lets an editor rewrite, and how a rewritten entry is judged */
+export interface StoryPartKind {
+    relType: string;
+    contentType: string;
+    /** Where the reader found this part, and null for a package that holds none */
+    pathIn(session: SessionStore): string | null;
+    /**
+     * Where the part goes when it is written: where it already sits, or the first name in the
+     * story's own folder that no part of the package has taken.
+     */
+    writePathIn(session: SessionStore): string;
+    /**
+     * The part's entries keyed by the id the story or a sibling part refers to them by, and null
+     * for a submitted part this editor's writer could not have put out at all.
+     */
+    entriesIn(session: SessionStore, reading: EntryReading): ReadonlyMap<string, StoryEntry> | null;
+    /**
+     * Whether the element the entries stand in came back as it left, save for the compatibility
+     * markup the writer declares on a part it writes a thread key into.
+     */
+    rootKept(before: SessionStore, after: SessionStore): boolean;
+    /** The keys this file still stands behind, which is what an entry has to be keyed by */
+    referents(story: Story): ReadonlySet<string>;
+    /** Grammar alone: whether the entry is one this editor's writer could have put out, whoever it belongs to */
+    wellFormed(entry: Element): boolean;
+    /**
+     * Whether the entry came back differing from the one that arrived in nothing but a change this
+     * protection leaves to everyone. Such an entry is nobody's rewrite, so it is held neither to
+     * the grammar this editor writes in nor to who owns it.
+     */
+    anyonesChange(entry: Element, original: Element): boolean;
+    /**
+     * Permission alone: whether `authorId` may have written (`original === null`) or rewritten this
+     * entry under `options`. `session` is the submission's, so a kind can look across at a sibling
+     * part, the way a comment's author resolves through the people part.
+     */
+    allowed(entry: Element, original: Element | null, authorId: string, options: PolicyOptions, session: SessionStore): boolean;
+}
+/** The two reasons the package comparison answers with, whatever the policy */
+export type PackageReason = "part-changed" | "relationship-changed";
+/**
+ * The shape every verdict takes: a story reason carries no part, a part reason names the part it
+ * was reached over. A public verdict keeps its own declaration and is one instance of this.
+ */
+export type ChangeVerdict<StoryReason extends string, PartReason extends string> = {
+    ok: true;
+} | {
+    ok: false;
+    reason: StoryReason;
+} | {
+    ok: false;
+    reason: PartReason;
+    part: string;
+};
+export interface ProtectionPolicy<StoryReason extends string, PartReason extends string> {
+    level: EditingProtection;
+    parts: readonly StoryPartKind[];
+    /** The reason a rewritten entry is refused under when no part takes it as well formed and allowed */
+    rejectedMarkup: PartReason;
+    /** Whether the story reads the same once this protection's own markup is taken out */
+    storyKept(before: Story, after: Story, authorId: string, options: PolicyOptions): ChangeVerdict<StoryReason, PartReason>;
+}
+/** Records the policy under its level and hands it back, so a module declares and registers at once */
+export declare function registerProtectionPolicy<S extends string, P extends string>(policy: ProtectionPolicy<S, P>): ProtectionPolicy<S, P>;
+/**
+ * The policy for a level, and undefined for a level no loaded module declares one for, `none` and
+ * `readOnly` among them.
+ */
+export declare function protectionPolicyFor(level: EditingProtection): ProtectionPolicy<string, string> | undefined;
+/**
+ * Whether the parts this protection lets an edit rewrite came back holding only entries this
+ * editor writes, each of them one this author was in a position to write.
+ *
+ * This runs after the story has been judged, so a comment rewritten, re-anchored or deleted by the
+ * wrong hand is already named for what it is. What is left to this is everything the story cannot
+ * show: markup forged into a body, an entry nothing refers to, an identity recorded for somebody
+ * else.
+ */
+export declare function partsKept<P extends string>(policy: ProtectionPolicy<string, P>, before: Story, after: Story, authorId: string, options: PolicyOptions): ChangeVerdict<never, P>;
+/**
+ * Whether the submitted file differs from the original in nothing this protection forbids.
+ *
+ * Both files are opened inside the one parser scope, so the parser named here is the parser both
+ * reads go through even though neither `importDocx` call is given it. The package is judged first,
+ * then the story, then the parts the policy excused from the package comparison: the parts are
+ * last so that an edit the wrong hand made is named for the edit rather than for the part it was
+ * written across.
+ */
+export declare function verifyChange<S extends string, P extends string>(policy: ProtectionPolicy<S, P>, original: DocxBytes, submitted: DocxBytes, authorId: string, { xmlParser, ...options }: VerifyOptions): ChangeVerdict<S, P | PackageReason>;