@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/commentOnlyChange.js

@@ -1,144 +1,14 @@
 // src/docx/commentOnlyChange.ts
-import { decodeUtf8, elementChildren, parseXml } from "../ooxml/xml.js";
-import {
-  changesOnlyComments,
-  commentAdditionsBy,
-  commentEditsOwned,
-  commentIdentitiesKept
-} from "../schema/protection.js";
-import {
-  COMMENTS_CONTENT_TYPE,
-  COMMENTS_EXTENDED_CONTENT_TYPE,
-  COMMENTS_EXTENDED_REL_TYPE,
-  COMMENTS_REL_TYPE,
-  CONTENT_TYPES_PATH,
-  PEOPLE_CONTENT_TYPE,
-  PEOPLE_REL_TYPE
-} from "./comments/constants.js";
-import { importDocx } from "./importDocx.js";
-import {
-  readRelationships,
-  relsPathOf,
-  resolveTarget
-} from "./relationships.js";
-var COMMENT_REL_TYPES = [
-  COMMENTS_REL_TYPE,
-  COMMENTS_EXTENDED_REL_TYPE,
-  PEOPLE_REL_TYPE
-];
-var COMMENT_CONTENT_TYPES = [
-  COMMENTS_CONTENT_TYPE,
-  COMMENTS_EXTENDED_CONTENT_TYPE,
-  PEOPLE_CONTENT_TYPE
-];
-var refused = (reason) => ({ ok: false, reason });
-function sameBytes(before, after) {
-  return before.length === after.length && before.every((byte, index) => byte === after[index]);
-}
-function commentPartPaths(session) {
-  const related = readRelationships(
-    session.parts,
-    relsPathOf(session.mainPartPath)
-  ).filter(
-    (entry) => !entry.external && COMMENT_REL_TYPES.includes(entry.type)
-  );
-  return new Set(
-    related.map((entry) => resolveTarget(session.mainPartPath, entry.target))
-  );
-}
-function aroundTheStory(session) {
-  const preserved = session.blocks.filter(
-    (block) => block.node.type.name !== "paragraph" && block.node.type.name !== "table"
-  ).map((block) => block.xml).join("");
-  return session.documentPrefix + preserved + session.documentSuffix;
-}
-function relationshipsKept(before, after) {
-  const now = new Map(after.map((entry) => [entry.id, entry]));
-  const kept = before.every((entry) => {
-    const current = now.get(entry.id);
-    return current !== void 0 && current.type === entry.type && current.target === entry.target && current.external === entry.external;
+import { commentsPolicy } from "./comments/policy.js";
+import { verifyChange } from "./protectionPolicy.js";
+function onlyCommentsChangedBy(original, submitted, authorId, {
+  editableComments = "own",
+  xmlParser
+} = {}) {
+  return verifyChange(commentsPolicy, original, submitted, authorId, {
+    editableComments,
+    xmlParser
   });
-  const ids = new Set(before.map((entry) => entry.id));
-  return kept && after.every(
-    (entry) => ids.has(entry.id) || COMMENT_REL_TYPES.includes(entry.type)
-  );
-}
-function contentTypes(bytes) {
-  if (bytes === void 0) return /* @__PURE__ */ new Map();
-  const declared = /* @__PURE__ */ new Map();
-  for (const el of elementChildren(
-    parseXml(decodeUtf8(bytes).text).documentElement
-  )) {
-    const key = el.localName === "Default" ? el.getAttribute("Extension") : el.localName === "Override" ? el.getAttribute("PartName") : null;
-    if (key !== null) declared.set(key, el.getAttribute("ContentType") ?? "");
-  }
-  return declared;
-}
-function contentTypesKept(before, after) {
-  for (const [key, type] of before) {
-    if (after.get(key) !== type) return false;
-  }
-  for (const [key, type] of after) {
-    if (!before.has(key) && !COMMENT_CONTENT_TYPES.includes(type)) return false;
-  }
-  return true;
-}
-function packageKept(before, after) {
-  if (before.mainPartPath !== after.mainPartPath) {
-    return { ok: false, reason: "part-changed", part: before.mainPartPath };
-  }
-  const relsPath = relsPathOf(before.mainPartPath);
-  const untouched = /* @__PURE__ */ new Set([
-    before.mainPartPath,
-    relsPath,
-    CONTENT_TYPES_PATH,
-    ...commentPartPaths(before),
-    ...commentPartPaths(after)
-  ]);
-  for (const path of /* @__PURE__ */ new Set([...before.parts.keys(), ...after.parts.keys()])) {
-    if (untouched.has(path)) continue;
-    const was = before.parts.get(path);
-    const now = after.parts.get(path);
-    if (was === void 0 || now === void 0 || !sameBytes(was, now)) {
-      return { ok: false, reason: "part-changed", part: path };
-    }
-  }
-  if (!relationshipsKept(
-    readRelationships(before.parts, relsPath),
-    readRelationships(after.parts, relsPath)
-  )) {
-    return { ok: false, reason: "relationship-changed", part: relsPath };
-  }
-  if (!contentTypesKept(
-    contentTypes(before.parts.get(CONTENT_TYPES_PATH)),
-    contentTypes(after.parts.get(CONTENT_TYPES_PATH))
-  )) {
-    return { ok: false, reason: "part-changed", part: CONTENT_TYPES_PATH };
-  }
-  if (aroundTheStory(before) !== aroundTheStory(after)) {
-    return { ok: false, reason: "part-changed", part: before.mainPartPath };
-  }
-  return { ok: true };
-}
-function storyKept(before, after, authorId, editableComments) {
-  if (!changesOnlyComments(before, after)) return refused("body-changed");
-  if (!commentIdentitiesKept(before, after) || !commentAdditionsBy(before, after, authorId)) {
-    return refused("comment-author-forged");
-  }
-  if (!commentEditsOwned(before, after, {
-    protection: "comments",
-    authorId,
-    editableComments
-  })) {
-    return refused("comment-not-owned");
-  }
-  return { ok: true };
-}
-function onlyCommentsChangedBy(original, submitted, authorId, { editableComments = "own" } = {}) {
-  const before = importDocx(original);
-  const after = importDocx(submitted);
-  const packaged = packageKept(before.session, after.session);
-  return packaged.ok ? storyKept(before.doc, after.doc, authorId, editableComments) : packaged;
 }
 export {
   onlyCommentsChangedBy

package/dist/docx/comments/constants.d.ts

@@ -2,10 +2,9 @@ export declare const COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/offi
 export declare const COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
 export declare const COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
 export declare const COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
-export declare const CONTENT_TYPES_PATH = "[Content_Types].xml";
-export declare const W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
-export declare const W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
-export declare const MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+export declare const W14_NS: "http://schemas.microsoft.com/office/word/2010/wordml";
+export declare const W15_NS: "http://schemas.microsoft.com/office/word/2012/wordml";
+export declare const MC_NS: "http://schemas.openxmlformats.org/markup-compatibility/2006";
 export declare const PEOPLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/people";
 export declare const PEOPLE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.people+xml";
 /**

package/dist/docx/comments/constants.js

@@ -1,13 +1,13 @@
 // src/docx/comments/constants.ts
+import { NAMESPACES } from "../../ooxml/names.js";
 import { R_NS } from "../../ooxml/xml.js";
 var COMMENTS_REL_TYPE = `${R_NS}/comments`;
 var COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
 var COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
 var COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
-var CONTENT_TYPES_PATH = "[Content_Types].xml";
-var W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
-var W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
-var MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var W14_NS = NAMESPACES.w14;
+var W15_NS = NAMESPACES.w15;
+var MC_NS = NAMESPACES.mc;
 var PEOPLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/people";
 var PEOPLE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.people+xml";
 var COMMENT_AUTHOR_PROVIDER = "portone-docx-editor";
@@ -17,7 +17,6 @@ export {
   COMMENTS_EXTENDED_REL_TYPE,
   COMMENTS_REL_TYPE,
   COMMENT_AUTHOR_PROVIDER,
-  CONTENT_TYPES_PATH,
   MC_NS,
   PEOPLE_CONTENT_TYPE,
   PEOPLE_REL_TYPE,

package/dist/docx/comments/grammar.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The shapes this editor writes the three comment parts in, and the reading of those shapes.
+ *
+ * Each entry is written here and judged here, so the two halves cannot drift apart: a body written
+ * by hand can be told from one this editor put out only where the writer and the reader agree on
+ * what it puts out. `./reading` keeps a lenient flattener for display, which takes whatever a
+ * producer wrote and shows what it can; this one judges an entry that came back and says no to
+ * everything else.
+ */
+import { type XmlAttr } from "../../ooxml/element";
+import type { CommentReferenceData, CommentReplyData } from "./model";
+/** The attributes this editor writes on a `w:comment`. The thread key goes on the body's paragraph */
+export declare const COMMENT_ATTRIBUTES: ReadonlySet<string>;
+/** The attributes this editor writes on a `w15:commentEx` */
+export declare const COMMENT_EX_ATTRIBUTES: ReadonlySet<string>;
+/**
+ * Whether the namespace declaration is one this editor's writer puts out, its value included.
+ *
+ * A declaration decides what every name around it means, so one binding a prefix to a namespace
+ * this package does not write is markup the writer did not put there however ordinary the names
+ * under it look. The default declaration is never one of them: the writer spells out a prefix on
+ * everything it writes.
+ */
+export declare function declarationWritten(attr: Attr): boolean;
+/**
+ * Whether the element carries no attribute outside this set, and declares no namespace outside
+ * what the writer declares.
+ */
+export declare function attributesWithin(el: Element, allowed: ReadonlySet<string>): boolean;
+/** The body of a comment, as a paragraph of one run holding the text and the breaks in it */
+export declare function renderCommentBody(text: string, paraId: string | null): string;
+/**
+ * The paragraph a thread key belongs on, which is the last one of the body.
+ *
+ * A body may hold a paragraph of another vocabulary, a picture's DrawingML `a:p` among them, and a
+ * key put on that says nothing about the thread. The namespace decides, since a prefix means only
+ * what the element it sits on binds it to, and a document may bind the same prefix twice over.
+ */
+export declare function lastBodyParagraph(comment: Element): Element | null;
+/**
+ * The entries a part arrived holding, under the id each carries.
+ *
+ * The writer asks the document which paragraph a key goes on rather than asking the text, because
+ * only the document knows what a prefix means where it is written.
+ */
+export declare function arrivedEntries(partXml: string | null): ReadonlyMap<string, Element>;
+/**
+ * The entry with the thread key on its body's last paragraph, and unchanged where it has one.
+ *
+ * Settling a thread or replying to it hangs the state off that key, and an entry that arrived
+ * without one has to gain it. Writing the entry afresh instead would put back only what this
+ * editor models, so a body holding more than plain text would lose it to a change nobody asked
+ * for and nobody made.
+ *
+ * `arrived` is that entry as the document has it, which is what says which paragraph is a
+ * WordprocessingML one and whether it already carries a key under some prefix. The text is only
+ * asked where that paragraph is: its opening tag is the one at the same place among the tags named
+ * `p`, counted the same way in both.
+ *
+ * The `w14` prefix is declared on the part rather than here: a part holding any thread state
+ * declares it on its root along with the compatibility markup that goes with it (`./writing`).
+ */
+export declare function withThreadKey(commentXml: string, paraId: string, arrived: Element | null): string;
+/**
+ * The text of a comment written in that shape, and null for an entry holding anything else: a
+ * field, a second run, markup a producer wrapped it in, an attribute this editor does not write.
+ *
+ * An entry that arrived and was not edited is compared as it stands rather than read here, so
+ * saying no to a shape this editor would not have written turns down only a rewrite.
+ */
+/** Whether this editor's writer could have put out this thread state */
+export declare function wellFormedCommentExtension(entry: Element): boolean;
+/** Whether this editor's writer could have put out this recorded identity */
+export declare function wellFormedPerson(entry: Element): boolean;
+/** The identity a recorded person stands for, and null for an entry recording none */
+export declare function recordedIdentity(person: Element): string | null;
+export declare function readStrictCommentBody(comment: Element): string | null;
+/** The thread state of one comment, as this editor writes it into the extended part */
+export declare function renderCommentExtension(comment: CommentReferenceData | CommentReplyData): string;
+/**
+ * The identity this editor records for an author, as it writes it into the people part.
+ *
+ * The prefix and the declaration come from the caller, which is writing into a part whose root
+ * already binds them or is being written from nothing.
+ */
+export declare function renderPerson(author: string, userId: string, prefix: string, declaration: XmlAttr | null): string;

package/dist/docx/comments/grammar.js

@@ -0,0 +1,223 @@
+// src/docx/comments/grammar.ts
+import {
+  attrsText,
+  elementXml,
+  xmlnsAttr
+} from "../../ooxml/element.js";
+import { NAMESPACES, qualify, wName } from "../../ooxml/names.js";
+import {
+  attributeByLocalName,
+  elementChildren,
+  escapeXml,
+  parseXml,
+  W_NS
+} from "../../ooxml/xml.js";
+import { COMMENT_AUTHOR_PROVIDER, W14_NS, W15_NS } from "./constants.js";
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var XMLNS_NS = "http://www.w3.org/2000/xmlns/";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var nameKey = (namespace, localName) => `${namespace ?? ""} ${localName}`;
+var COMMENT_ATTRIBUTES = /* @__PURE__ */ new Set([
+  nameKey(W_NS, "id"),
+  nameKey(W_NS, "author"),
+  nameKey(W_NS, "date"),
+  nameKey(W_NS, "initials")
+]);
+var COMMENT_EX_ATTRIBUTES = /* @__PURE__ */ new Set([
+  nameKey(W15_NS, "paraId"),
+  nameKey(W15_NS, "paraIdParent"),
+  nameKey(W15_NS, "done")
+]);
+var PARAGRAPH_ATTRIBUTES = /* @__PURE__ */ new Set([
+  nameKey(W14_NS, "paraId")
+]);
+var TEXT_ATTRIBUTES = /* @__PURE__ */ new Set([
+  nameKey(XML_NS, "space")
+]);
+var PERSON_ATTRIBUTES = /* @__PURE__ */ new Set([
+  nameKey(W15_NS, "author")
+]);
+var PRESENCE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  nameKey(W15_NS, "providerId"),
+  nameKey(W15_NS, "userId")
+]);
+var NO_ATTRIBUTES = /* @__PURE__ */ new Set();
+var THREAD_KEY = /^[0-9A-Fa-f]{8}$/;
+function threadKeyOrNone(el, localName) {
+  const value = attributeByLocalName(el, localName);
+  return value === null || THREAD_KEY.test(value);
+}
+var WRITTEN_NAMESPACES = /* @__PURE__ */ new Map([
+  ["w", NAMESPACES.w],
+  ["w14", NAMESPACES.w14],
+  ["w15", NAMESPACES.w15]
+]);
+function declarationWritten(attr) {
+  if (!attr.name.startsWith("xmlns:")) return false;
+  return WRITTEN_NAMESPACES.get(attr.name.slice("xmlns:".length)) === attr.value;
+}
+function attributesWithin(el, allowed) {
+  return Array.from(el.attributes).every(
+    (attr) => attr.namespaceURI === XMLNS_NS ? declarationWritten(attr) : allowed.has(nameKey(attr.namespaceURI, attr.localName))
+  );
+}
+function isNamed(el, namespace, localName) {
+  return el.namespaceURI === namespace && el.localName === localName;
+}
+function holdsElementsOnly(el) {
+  return Array.from(el.childNodes).every(
+    (node) => node.nodeType === ELEMENT_NODE
+  );
+}
+function holdsTextOnly(el) {
+  return Array.from(el.childNodes).every((node) => node.nodeType === TEXT_NODE);
+}
+function renderCommentBody(text, paraId) {
+  const lines = text.split("\n");
+  const pieces = [];
+  lines.forEach((line, index) => {
+    if (index > 0) pieces.push(elementXml(wName("br"), []));
+    if (line.length > 0 || lines.length === 1) {
+      pieces.push(
+        elementXml(wName("t"), [["xml:space", "preserve"]], [escapeXml(line)])
+      );
+    }
+  });
+  const key = paraId === null ? [] : [xmlnsAttr("w14"), [qualify("w14", "paraId"), paraId]];
+  return elementXml(wName("p"), key, [elementXml(wName("r"), [], pieces)]);
+}
+var PARAGRAPH_OR_SKIPPED = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<([^\s<>/:="']+:)?p(?=[\s/>])[^>]*>/g;
+function lastBodyParagraph(comment) {
+  const paragraphs = comment.getElementsByTagNameNS(W_NS, "p");
+  return paragraphs.length === 0 ? null : paragraphs[paragraphs.length - 1];
+}
+function namedParagraphs(comment) {
+  return Array.from(comment.getElementsByTagName("*")).filter(
+    (element) => element.localName === "p"
+  );
+}
+function arrivedEntries(partXml) {
+  const entries = /* @__PURE__ */ new Map();
+  if (partXml === null) return entries;
+  let root;
+  try {
+    root = parseXml(partXml).documentElement;
+  } catch {
+    return entries;
+  }
+  for (const entry of elementChildren(root)) {
+    if (entry.namespaceURI !== W_NS || entry.localName !== "comment") continue;
+    const id = attributeByLocalName(entry, "id");
+    if (id !== null && !entries.has(id)) entries.set(id, entry);
+  }
+  return entries;
+}
+function withThreadKey(commentXml, paraId, arrived) {
+  if (arrived === null) return commentXml;
+  const target = lastBodyParagraph(arrived);
+  if (target === null) return commentXml;
+  if (target.getAttributeNS(W14_NS, "paraId") !== null || target.hasAttribute("w14:paraId")) {
+    return commentXml;
+  }
+  const at = namedParagraphs(arrived).indexOf(target);
+  const openings = Array.from(commentXml.matchAll(PARAGRAPH_OR_SKIPPED)).filter(
+    (match) => !match[0].startsWith("<!")
+  );
+  const opening = openings[at];
+  if (at === -1 || opening === void 0 || opening.index === void 0) {
+    return commentXml;
+  }
+  const selfClosing = opening[0].endsWith("/>");
+  const keyed = opening[0].slice(0, selfClosing ? -2 : -1) + ` ${attrsText([[qualify("w14", "paraId"), paraId]])}` + (selfClosing ? "/>" : ">");
+  return commentXml.slice(0, opening.index) + keyed + commentXml.slice(opening.index + opening[0].length);
+}
+function readRunText(run) {
+  if (!holdsElementsOnly(run)) return null;
+  const pieces = [];
+  for (const child of Array.from(run.children)) {
+    if (isNamed(child, W_NS, "br")) {
+      if (!attributesWithin(child, NO_ATTRIBUTES) || child.childNodes.length > 0) {
+        return null;
+      }
+      pieces.push("\n");
+      continue;
+    }
+    if (!isNamed(child, W_NS, "t")) return null;
+    if (!attributesWithin(child, TEXT_ATTRIBUTES) || child.getAttributeNS(XML_NS, "space") !== "preserve" || !holdsTextOnly(child)) {
+      return null;
+    }
+    pieces.push(child.textContent ?? "");
+  }
+  return pieces.join("");
+}
+function wellFormedCommentExtension(entry) {
+  return attributesWithin(entry, COMMENT_EX_ATTRIBUTES) && entry.childNodes.length === 0 && threadKeyOrNone(entry, "paraId") && threadKeyOrNone(entry, "paraIdParent") && // The writer says a thread is settled or open, and nothing else `ST_OnOff` would take
+  ["0", "1", null].includes(attributeByLocalName(entry, "done"));
+}
+function wellFormedPerson(entry) {
+  if (!attributesWithin(entry, PERSON_ATTRIBUTES)) return false;
+  if (!holdsElementsOnly(entry)) return false;
+  const children = Array.from(entry.children);
+  if (children.length !== 1) return false;
+  const [presence] = children;
+  return isNamed(presence, W15_NS, "presenceInfo") && attributesWithin(presence, PRESENCE_ATTRIBUTES) && attributeByLocalName(presence, "providerId") === COMMENT_AUTHOR_PROVIDER && attributeByLocalName(presence, "userId") !== null && presence.childNodes.length === 0;
+}
+function recordedIdentity(person) {
+  const [presence] = Array.from(person.children);
+  return presence === void 0 ? null : attributeByLocalName(presence, "userId");
+}
+function readStrictCommentBody(comment) {
+  if (!holdsElementsOnly(comment)) return null;
+  const paragraphs = Array.from(comment.children);
+  if (paragraphs.length !== 1) return null;
+  const [paragraph] = paragraphs;
+  if (!isNamed(paragraph, W_NS, "p")) return null;
+  if (!attributesWithin(paragraph, PARAGRAPH_ATTRIBUTES)) return null;
+  if (!holdsElementsOnly(paragraph)) return null;
+  const runs = Array.from(paragraph.children);
+  if (runs.length !== 1) return null;
+  const [run] = runs;
+  if (!isNamed(run, W_NS, "r")) return null;
+  if (!attributesWithin(run, NO_ATTRIBUTES)) return null;
+  return readRunText(run);
+}
+function renderCommentExtension(comment) {
+  if (comment.extensionXml !== null) return comment.extensionXml;
+  const parent = "parentParaId" in comment ? [[qualify("w15", "paraIdParent"), comment.parentParaId]] : [];
+  const done = "resolved" in comment ? [[qualify("w15", "done"), comment.resolved ? "1" : "0"]] : [];
+  return elementXml(qualify("w15", "commentEx"), [
+    [qualify("w15", "paraId"), comment.paraId],
+    ...parent,
+    ...done
+  ]);
+}
+function renderPerson(author, userId, prefix, declaration) {
+  const declared = declaration === null ? [] : [declaration];
+  return elementXml(
+    `${prefix}person`,
+    [...declared, [`${prefix}author`, author]],
+    [
+      elementXml(`${prefix}presenceInfo`, [
+        [`${prefix}providerId`, COMMENT_AUTHOR_PROVIDER],
+        [`${prefix}userId`, userId]
+      ])
+    ]
+  );
+}
+export {
+  COMMENT_ATTRIBUTES,
+  COMMENT_EX_ATTRIBUTES,
+  arrivedEntries,
+  attributesWithin,
+  declarationWritten,
+  lastBodyParagraph,
+  readStrictCommentBody,
+  recordedIdentity,
+  renderCommentBody,
+  renderCommentExtension,
+  renderPerson,
+  wellFormedCommentExtension,
+  wellFormedPerson,
+  withThreadKey
+};

package/dist/docx/comments/parts.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The three parts a comment is written across, each declared once: where it sits, what it is
+ * declared as in the package, what an entry in it looks like, and who may have written one.
+ *
+ * The writer named the relationship and the content type where it added a part and the verifier
+ * named them again where it excused one, so the two were free to drift apart. Both read this
+ * instead, which is what makes a part the editor writes a part it takes back.
+ *
+ * What an entry is held to is two separate questions. Grammar asks whether this editor's writer
+ * could have put the entry out, whoever it belongs to. Permission asks whether this author could
+ * have made the change. Asking them as one would refuse a moderator rewriting somebody else's
+ * comment under `editableComments: "all"`, which is a thing the editor lets them do.
+ */
+import type { EditableComments } from "../../schema/protection";
+import type { StoryPartKind } from "../protectionPolicy";
+import { type ImportedPeople } from "./people";
+/**
+ * Whether this editor's writer could have put the entry out, whoever it belongs to.
+ *
+ * Shape alone: which attributes it carries and what stands inside it. Who may have written it is
+ * `entryAllowed`'s question. Each kind is read where it is written (`./grammar`).
+ */
+export declare function wellFormedEntry(entry: Element): boolean;
+/**
+ * Whether the only thing between the two is that a thread gained its key.
+ *
+ * Settling a thread or replying to it belongs to everyone and leaves what the comment says alone,
+ * and the writer answers by putting the key on the entry that arrived rather than writing one of
+ * its own (`./grammar`). Such an entry is not a rewrite, so it is neither held to the grammar this
+ * editor writes bodies in nor to who owns the comment.
+ */
+export declare function threadKeyAlone(entry: Element, original: Element): boolean;
+/**
+ * Whether `authorId` could have written or rewritten this entry.
+ *
+ * Permission alone: whether the shape is one this editor writes is `wellFormedEntry`'s question.
+ * An entry that appeared has to be this author's. One that arrived keeps the identity it arrived
+ * with; settling its thread or replying to it belong to everyone and leave what it says alone,
+ * while rewriting what it says is its author's, a moderator's, or anyone's where no identity was
+ * recorded for it. That last is the rule the editor holds to (`schema/protection`), and the two
+ * have to answer alike or a file the editor wrote would be turned down here.
+ */
+export declare function entryAllowed(entry: Element, original: Element | null, authorId: string, editableComments: EditableComments, people: ImportedPeople): boolean;
+export declare const commentsPart: StoryPartKind;
+export declare const commentsExtendedPart: StoryPartKind;
+export declare const peoplePart: StoryPartKind;
+/** The parts a comment protection lets an edit rewrite, in the order an export writes them */
+export declare const COMMENT_STORY_PARTS: readonly [
+    StoryPartKind,
+    StoryPartKind,
+    StoryPartKind
+];