@portone/docx-editor 0.4.0 → 0.5.1

package/dist/docx/story.js

@@ -0,0 +1,237 @@
+// src/docx/story.ts
+import { Fragment } from "prosemirror-model";
+import { xmlnsAttr } from "../ooxml/element.js";
+import { DocxImportError } from "../ooxml/errors.js";
+import { NAMESPACES, qualify } from "../ooxml/names.js";
+import { attributeByLocalName, elementChildren, parseXml } from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import { isPreservedNode } from "../schema/preservedFragments.js";
+import {
+  STORIES_ATTR,
+  storiesOf,
+  storyKey,
+  storyNodeOf
+} from "../schema/stories.js";
+import { styledParagraph } from "./formatting.js";
+import { buildParagraph } from "./importParagraph.js";
+import { buildPreservedBlock } from "./importPreserved.js";
+import { buildTable } from "./importTable.js";
+import { scanBlocksIn } from "./scan.js";
+import { blockKey } from "./session.js";
+import {
+  asStoryKey,
+  sameStory,
+  storiesOf as storiesOf2,
+  storyKey as storyKey2,
+  withoutCommentStories
+} from "../schema/stories.js";
+var storyOf = storyNodeOf;
+function buildBlock(el, srcId, sources, context) {
+  if (el.localName === "p") return buildParagraph(el, srcId, sources);
+  if (el.localName === "tbl") {
+    const table = buildTable(el, srcId, sources, context);
+    if (table) return table;
+  }
+  return buildPreservedBlock(el, srcId, "body");
+}
+function withStyleFormats(node, context) {
+  if (node.type === docxSchema.nodes.paragraph) {
+    return styledParagraph(node, context);
+  }
+  if (node.childCount === 0 || node.type === docxSchema.nodes.table) {
+    return node;
+  }
+  const children = node.children.map(
+    (child) => withStyleFormats(child, context)
+  );
+  if (children.every((child, i) => child === node.child(i))) return node;
+  return node.copy(Fragment.fromArray(children));
+}
+function malformed(what) {
+  throw new DocxImportError("malformed-xml", what);
+}
+var SELF_CLOSING = /\/>\s*$/;
+function scanElement(xml, el) {
+  const scan = scanBlocksIn(xml, (_tag, depth) => depth === 0);
+  if (scan !== null) return scan;
+  if (!SELF_CLOSING.test(xml) || el.children.length > 0) {
+    malformed(`no ${el.nodeName} element to read from`);
+  }
+  return {
+    prefix: xml.replace(SELF_CLOSING, ">"),
+    blocks: [],
+    suffix: `</${el.nodeName}>`
+  };
+}
+function scanContainer(xml, el) {
+  const scan = scanElement(xml, el);
+  const children = elementChildren(el);
+  if (children.length !== scan.blocks.length) {
+    malformed(
+      `the block count of ${el.nodeName} differs between the scan and the DOM`
+    );
+  }
+  children.forEach((child, at) => {
+    if (child.nodeName !== scan.blocks[at].name) {
+      malformed(
+        `story block names disagree: ${child.nodeName} vs ${scan.blocks[at].name}`
+      );
+    }
+  });
+  return { scan, children };
+}
+function readStory(place, container, deps) {
+  const key = storyKey(place.kind, place.id);
+  const { scan, children } = scanContainer(container.xml, container.el);
+  const nodes = children.map(
+    (child, at) => withStyleFormats(
+      buildBlock(
+        child,
+        blockKey(deps.session, key, at),
+        deps.sources,
+        deps.formatting
+      ),
+      deps.formatting
+    )
+  );
+  const blocks = nodes.map((node, at) => ({
+    xml: scan.blocks[at].xml,
+    node
+  }));
+  if (nodes.length === 0) {
+    const placeholder = withStyleFormats(
+      docxSchema.nodes.paragraph.create({
+        srcId: blockKey(deps.session, key, 0)
+      }),
+      deps.formatting
+    );
+    nodes.push(placeholder);
+    blocks.push({ xml: "", node: placeholder });
+  }
+  return {
+    key,
+    kind: place.kind,
+    id: place.id,
+    partPath: place.partPath,
+    xml: container.xml,
+    open: scan.prefix,
+    close: scan.suffix,
+    blocks,
+    doc: docxSchema.nodes.doc.create(null, nodes)
+  };
+}
+function readStories(part, deps) {
+  const root = parseXml(part.xml).documentElement;
+  const scan = scanElement(part.xml, root);
+  const children = elementChildren(root);
+  if (children.length !== scan.blocks.length) {
+    malformed(
+      `the entry count of ${part.partPath} differs between the scan and the DOM`
+    );
+  }
+  const stories = [];
+  const seen = /* @__PURE__ */ new Set();
+  children.forEach((el, at) => {
+    if (el.localName !== part.entryName) return;
+    const id = attributeByLocalName(el, part.idAttr);
+    if (id === null || seen.has(id)) return;
+    seen.add(id);
+    const xml = scan.blocks[at].xml;
+    stories.push(
+      readStory(
+        { kind: part.kind, id, partPath: part.partPath },
+        { el, xml: xml.slice(xml.indexOf("<")) },
+        deps
+      )
+    );
+  });
+  return stories;
+}
+function storiesByKey(stories) {
+  return new Map(Array.from(stories, (story) => [story.key, story]));
+}
+function setStory(tr, key, story) {
+  const json = story.toJSON();
+  return tr.setDocAttribute(STORIES_ATTR, {
+    ...storiesOf(tr.doc),
+    [key]: json
+  });
+}
+function withoutStories(tr, keys) {
+  const dropped = new Set(keys);
+  const stories = storiesOf(tr.doc);
+  const kept = Object.fromEntries(
+    Object.entries(stories).filter(([held]) => !dropped.has(held))
+  );
+  if (Object.keys(kept).length === Object.keys(stories).length) return tr;
+  return tr.setDocAttribute(STORIES_ATTR, kept);
+}
+function storyFromText(text) {
+  const pieces = [];
+  text.split("\n").forEach((line, at) => {
+    if (at > 0) pieces.push(docxSchema.nodes.hardBreak.create());
+    if (line.length > 0) pieces.push(docxSchema.text(line));
+  });
+  return docxSchema.nodes.doc.create(null, [
+    docxSchema.nodes.paragraph.create(null, pieces)
+  ]);
+}
+var EMBEDDED = /* @__PURE__ */ new Set([
+  "drawing",
+  "pict",
+  "object",
+  "AlternateContent"
+]);
+function storyLeafText(leaf) {
+  if (leaf.isText) return leaf.text ?? "";
+  if (leaf.type === docxSchema.nodes.hardBreak) return "\n";
+  if (!isPreservedNode(leaf)) return "";
+  const element = leaf.attrs.element;
+  if (typeof element === "string" && EMBEDDED.has(element)) return "";
+  if (leaf.attrs.display === "break") return "\n";
+  return typeof leaf.attrs.text === "string" ? leaf.attrs.text : "";
+}
+function storyText(story) {
+  if (story === null) return "";
+  return story.textBetween(0, story.content.size, "\n", storyLeafText);
+}
+function withThreadKeyOn(story, paraId) {
+  let at = -1;
+  story.forEach((block, _offset, index) => {
+    if (block.type === docxSchema.nodes.paragraph) at = index;
+  });
+  if (at === -1) return story;
+  const paragraph = story.child(at);
+  const written = paragraph.attrs.pAttrs;
+  const pAttrs = typeof written === "string" ? written : "";
+  if (/\bw14:paraId\s*=/.test(pAttrs)) return story;
+  const declared = /\bxmlns:w14\s*=/.test(pAttrs) ? "" : `${xmlnsAttr("w14")[0]}="${NAMESPACES.w14}" `;
+  const keyed = paragraph.type.create(
+    {
+      ...paragraph.attrs,
+      pAttrs: `${pAttrs === "" ? "" : `${pAttrs} `}${declared}${qualify("w14", "paraId")}="${paraId}"`
+    },
+    paragraph.content,
+    paragraph.marks
+  );
+  return story.copy(story.content.replaceChild(at, keyed));
+}
+export {
+  asStoryKey,
+  buildBlock,
+  readStories,
+  readStory,
+  sameStory,
+  setStory,
+  storiesByKey,
+  storiesOf2 as storiesOf,
+  storyFromText,
+  storyKey2 as storyKey,
+  storyLeafText,
+  storyOf,
+  storyText,
+  withStyleFormats,
+  withThreadKeyOn,
+  withoutCommentStories,
+  withoutStories
+};

package/dist/docx/storyProjection.js

@@ -9,7 +9,12 @@ function comparableStory(story, strip) {
   const blocks = [];
   try {
     story.doc.forEach((block) => {
-      blocks.push(serializeBlock(strip(block), story.session, NO_EXPORT_REFS));
+      blocks.push(
+        serializeBlock(strip(block), {
+          ...NO_EXPORT_REFS,
+          session: story.session
+        })
+      );
     });
   } catch (error) {
     if (error instanceof DocxExportError) return null;

package/dist/docx/tableTemplate.d.ts

@@ -8,8 +8,24 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type PageGeometry } from "./pageGeometry";
+import { type GridRect } from "./tableFormatting";
+/**
+ * The limit on how many rows and cells one table can hold.
+ * The toolbar grid lets you pick from something smaller (6x6); this only blocks absurd values.
+ */
+export declare const MAX_TABLE_SIDE = 50;
 /** Whether the value can be used as a row count or a cell count */
 export declare function isTableSide(value: number): boolean;
+/**
+ * One cell of a table being built: the block of the grid it covers, and the blocks it holds.
+ *
+ * A cell reaching across columns or down rows exists once, as the cell it starts at, which is how
+ * the model holds a merge and what `serializeTable` writes `w:gridSpan` and `w:vMerge` from.
+ */
+export interface TableCellPlan {
+    rect: GridRect;
+    content?: readonly PMNode[];
+}
 /**
  * A single table made up of nothing but empty cells.
  *
@@ -20,3 +36,12 @@ export declare function isTableSide(value: number): boolean;
  * The row and cell counts must be values that have passed through `isTableSide`.
  */
 export declare function createTableNode(rows: number, cols: number, geometry?: PageGeometry): PMNode;
+/**
+ * The same table, laid out and filled by the caller: the shape a table read off the clipboard
+ * takes, where the cells are neither all one wide nor all empty.
+ *
+ * Everything the table itself wears is the same as a newly inserted one's, so a pasted table is
+ * drawn and written exactly like a table the toolbar put there. The grid the cells are measured
+ * and dressed against is the one they cover between them, row by row.
+ */
+export declare function createTableNodeFrom(plan: readonly (readonly TableCellPlan[])[], geometry?: PageGeometry): PMNode;

package/dist/docx/tableTemplate.js

@@ -83,27 +83,43 @@ function cellTemplate(width, defaults) {
     format: readCellFormat(el, defaults)
   };
 }
-function cellNode(props) {
+function cellNode(props, plan) {
+  const content = plan.content ?? [];
   return docxSchema.nodes.tableCell.create(
     {
-      colspan: 1,
-      rowspan: 1,
+      colspan: plan.rect.right - plan.rect.left,
+      rowspan: plan.rect.bottom - plan.rect.top,
       colwidth: null,
       tcAttrs: null,
       tcPr: props.tcPr,
       tcW: props.tcW,
       format: props.format
     },
-    docxSchema.nodes.paragraph.create()
+    // A cell holds blocks, so one holding nothing still holds an empty paragraph
+    content.length === 0 ? docxSchema.nodes.paragraph.create() : [...content]
   );
 }
 function rowNode(cells) {
   return docxSchema.nodes.tableRow.create(
     { trAttrs: null, trPr: null, format: null },
-    cells.map(cellNode)
+    [...cells]
+  );
+}
+function evenCells(rows, cols) {
+  return Array.from(
+    { length: rows },
+    (_, row) => Array.from({ length: cols }, (_2, col) => ({
+      rect: { top: row, bottom: row + 1, left: col, right: col + 1 }
+    }))
   );
 }
 function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
+  return createTableNodeFrom(evenCells(rows, cols), geometry);
+}
+function createTableNodeFrom(plan, geometry = A4_PORTRAIT) {
+  const placed = plan.flat();
+  const rows = Math.max(plan.length, ...placed.map((cell) => cell.rect.bottom));
+  const cols = Math.max(1, ...placed.map((cell) => cell.rect.right));
   const total = bodyWidth(geometry).twips;
   const gridCols = evenGridCols(cols, total);
   const tblPr = tablePropsXml(total);
@@ -114,13 +130,12 @@ function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
     outer,
     inside: readInsideBorders(tblPrEl)
   };
-  const cellAt = (row, col) => cellTemplate(
-    gridCols[col],
-    cellDefaultsFor(
-      { top: row, bottom: row + 1, left: col, right: col + 1 },
-      { rows, cols },
-      sources
-    )
+  const cellAt = (cell) => cellNode(
+    cellTemplate(
+      gridCols.slice(cell.rect.left, cell.rect.right).reduce((width, column) => width + column, 0),
+      cellDefaultsFor(cell.rect, { rows, cols }, sources)
+    ),
+    cell
   );
   return docxSchema.nodes.table.create(
     {
@@ -131,13 +146,12 @@ function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
       gridCols,
       format: outer
     },
-    Array.from(
-      { length: rows },
-      (_, row) => rowNode(gridCols.map((_width, col) => cellAt(row, col)))
-    )
+    plan.map((row) => rowNode(row.map(cellAt)))
   );
 }
 export {
+  MAX_TABLE_SIDE,
   createTableNode,
+  createTableNodeFrom,
   isTableSide
 };

package/dist/docx/wrappers.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The inline wrappers this editor takes apart and puts back together, one entry each.
+ *
+ * A wrapper is an element holding inline content that goes back out around the same content: a
+ * content control (`w:sdt`, §17.5.2.17), a hyperlink (`w:hyperlink`, §17.16.22). `EG_PContent`
+ * lets them nest in any order and any depth, so import reads the nesting as the file wrote it and
+ * export rebuilds it from the marks (`schema/wrappers` holds the order, `docx/importParagraph`
+ * reads, `docx/serializeParagraph` writes).
+ *
+ * A kind knows three things and nothing about either walk: what a mark reads out of one element,
+ * what opens it again, and what closes it. Tracked changes (`w:ins`, `w:del`) and simple fields
+ * (`w:fldSimple`) are wrappers of the same shape. Registering one is an entry here and a mark spec
+ * in `schema/docxSchema` carrying `WRAPPER_ATTRS`; its attrs also want a row in
+ * `schema/attrRoles`, and two test lists name the kinds outright (`WRAPPERS_READS` in
+ * `schema/attrClasses.test.ts`, the kind list in `schema/wrappers.test.ts`). Neither paragraph walk
+ * and neither policy table has to be touched.
+ *
+ * The opening tag is the verbatim string the file wrote wherever there is one, so a wrapper nobody
+ * edited goes back out byte for byte; only the closing tag is written from scratch.
+ */
+import type { Mark } from "prosemirror-model";
+import type { ExportRefs } from "./exportRefs";
+import type { ImportSources } from "./importParagraph";
+/** A wrapper read off the file: the mark its content wears, and the element that content stands in */
+export interface WrapperReading {
+    mark: Mark;
+    content: Element;
+}
+/** One kind of inline wrapper, as import reads it and export writes it */
+export interface WrapperKind {
+    /** The mark name in the schema */
+    readonly mark: string;
+    /** The local name of the element it comes from */
+    readonly element: string;
+    /**
+     * The mark this element goes on and the content to read on inside it. null for a shape we do
+     * not write back ourselves, which leaves the element preserved whole where it stood.
+     */
+    read(el: Element, depth: number, sources: ImportSources): WrapperReading | null;
+    /** The opening XML this mark goes back out as */
+    open(mark: Mark, refs: ExportRefs): string;
+    /** What closes it again */
+    close(mark: Mark): string;
+    /**
+     * The same wrapper under a name of its own, for a second stretch claiming one name
+     * (`docx/identities`). Absent for a kind that names nothing a document must keep unique.
+     */
+    copy?(mark: Mark): Mark;
+}
+/**
+ * Every wrapper the editor models, in the order the schema declares their marks: what stands
+ * first here stands outside the others where two of them are written at one depth.
+ */
+export declare const WRAPPER_KINDS: readonly WrapperKind[];
+/** The kind this element is one of, undefined for an element no kind reads */
+export declare function wrapperKindFor(el: Element): WrapperKind | undefined;
+/**
+ * Whether a wrapper of this kind may be read inside the wrappers already around it.
+ *
+ * A kind whose mark excludes its own type records one of itself at a time, so the inner of two is
+ * left whole where it stood rather than pushing the outer one off the content it wraps: that is a
+ * `w:hyperlink` inside a `w:hyperlink`, which OOXML admits and Word does not write. A kind that
+ * excludes nothing nests as deeply as the file does (`w:sdt`, §17.5.2.17).
+ */
+export declare function wrapperFits(kind: WrapperKind, wrappers: readonly Mark[]): boolean;
+/** The kind this mark stands for. A wrapper mark nobody registered has no way back out */
+export declare function wrapperKindOf(mark: Mark): WrapperKind;

package/dist/docx/wrappers.js

@@ -0,0 +1,117 @@
+// src/docx/wrappers.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { docxSchema } from "../schema/index.js";
+import { readHyperlinkWrapper, relIdIn, withRelId } from "./hyperlink.js";
+import { copiedControlPrefix, newControlId, readSdtWrapper } from "./sdt.js";
+var counts = /* @__PURE__ */ new WeakMap();
+function nextKey(kind, el) {
+  const perDocument = counts.get(el.ownerDocument) ?? /* @__PURE__ */ new Map();
+  counts.set(el.ownerDocument, perDocument);
+  const key = perDocument.get(kind.mark) ?? 0;
+  perDocument.set(kind.mark, key + 1);
+  return key;
+}
+var SDT = {
+  mark: "sdt",
+  element: "sdt",
+  read(el, depth) {
+    const wrapper = readSdtWrapper(el);
+    if (!wrapper) return null;
+    return {
+      mark: docxSchema.marks.sdt.create({
+        sdtPrefix: wrapper.prefix,
+        depth,
+        key: nextKey(SDT, el),
+        contentsLocked: wrapper.contentsLocked,
+        deletionLocked: wrapper.deletionLocked
+      }),
+      content: wrapper.content
+    };
+  },
+  open(mark) {
+    const prefix = mark.attrs.sdtPrefix;
+    if (typeof prefix !== "string") {
+      throw new DocxExportError(
+        "lost-original",
+        "a content control has lost the opening XML it goes back out as"
+      );
+    }
+    return `${prefix}<w:sdtContent>`;
+  },
+  close: () => "</w:sdtContent></w:sdt>",
+  copy(mark) {
+    const prefix = mark.attrs.sdtPrefix;
+    if (typeof prefix !== "string") return mark;
+    return mark.type.create({
+      ...mark.attrs,
+      sdtPrefix: copiedControlPrefix(prefix, newControlId())
+    });
+  }
+};
+var LINK = {
+  mark: "link",
+  element: "hyperlink",
+  read(el, depth, sources) {
+    const wrapper = readHyperlinkWrapper(el);
+    if (!wrapper) return null;
+    return {
+      mark: docxSchema.marks.link.create({
+        linkPrefix: wrapper.prefix,
+        href: wrapper.relId === null ? null : sources.links.get(wrapper.relId) ?? null,
+        depth,
+        key: nextKey(LINK, el)
+      }),
+      content: el
+    };
+  },
+  open(mark, refs) {
+    const prefix = mark.attrs.linkPrefix;
+    const original = typeof prefix === "string" ? prefix : null;
+    const href = mark.attrs.href;
+    if (typeof href !== "string") {
+      if (original !== null) return original;
+      throw new DocxExportError(
+        "lost-original",
+        "a hyperlink carries neither an address nor the opening XML it goes back out as"
+      );
+    }
+    const relId = refs.links.relIdOf(
+      href,
+      original === null ? null : relIdIn(original)
+    );
+    if (relId === void 0) {
+      if (original !== null) return original;
+      throw new DocxExportError(
+        "unsupported-content",
+        "an inserted hyperlink has no relationship to point at; export it through exportDocx"
+      );
+    }
+    return withRelId(original ?? "<w:hyperlink>", relId);
+  },
+  close: () => "</w:hyperlink>"
+};
+var WRAPPER_KINDS = [SDT, LINK];
+function wrapperKindFor(el) {
+  return WRAPPER_KINDS.find((kind) => kind.element === el.localName);
+}
+function wrapperFits(kind, wrappers) {
+  const type = docxSchema.marks[kind.mark];
+  if (!type.excludes(type)) return true;
+  return !wrappers.some((mark) => mark.type === type);
+}
+function wrapperKindOf(mark) {
+  const kind = WRAPPER_KINDS.find((entry) => entry.mark === mark.type.name);
+  if (!kind) {
+    throw new DocxExportError(
+      "unsupported-content",
+      `inline wrapper we cannot serialize: ${mark.type.name}`
+    );
+  }
+  return kind;
+}
+export {
+  WRAPPER_KINDS,
+  wrapperFits,
+  wrapperKindFor,
+  wrapperKindOf
+};

package/dist/editor/clipboard/blockReaders.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The elements a reading takes as blocks of their own.
+ *
+ * Everything else in a piece of clipboard HTML is read by the shape of the markup alone: an
+ * element either names a block or it is text in the paragraph around it. A block reader is how an
+ * element that means more than its shape says - a table, a Word paragraph that is really a list
+ * item - is read as what it means, without the reading itself learning about the applications
+ * one by one.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ListKind } from "../../numbering/listTemplate";
+import { type InlineContext } from "./inlineFormatting";
+import type { HtmlReadContext } from "./readContext";
+/** Where one paragraph being read stands in a list */
+export interface ListPlacement {
+    kind: ListKind;
+    /** The number the list wears here, or null where this document may start no list */
+    numId: number | null;
+    /** How deep the item sits, counted from zero */
+    level: number;
+}
+/** What a block reader may ask of the reading it is part of */
+export interface HtmlBlockHost {
+    /** What the markup is being read against, including the application that wrote it */
+    readonly context: HtmlReadContext;
+    /** Whether the reading already stands inside a cell of a table it is reading */
+    readonly inTable: boolean;
+    /** The blocks the content of one cell reads as. None where the cell holds nothing */
+    readCell(cell: ParentNode, inline: InlineContext): readonly PMNode[];
+    /** The inline nodes these nodes read as */
+    readInline(nodes: Iterable<Node>, inline: InlineContext): readonly PMNode[];
+    /** One paragraph of the reading, as an item of the list it belongs to when it is one */
+    paragraph(content: readonly PMNode[], list?: ListPlacement | null): PMNode;
+    /**
+     * The number the pasted list this key names takes here. The same key answers the same number,
+     * so the paragraphs of one list join it rather than each starting a list of their own.
+     */
+    listNumber(key: string, kind: ListKind): number | null;
+}
+/**
+ * One kind of element read as blocks of its own rather than as text where it stands.
+ *
+ * A reader answers null for an element it has nothing to say about, so that deciding whether an
+ * element is its own and reading it are one pass rather than two.
+ */
+export interface HtmlBlockReader {
+    read(element: HTMLElement, inline: InlineContext, host: HtmlBlockHost): readonly PMNode[] | null;
+}
+/**
+ * An HTML table, read as a table of this document.
+ *
+ * The cells hold what their own markup reads as, one paragraph per block they hold, and the table
+ * is as wide as a table inserted here would be: a pasted table is drawn and written out exactly
+ * like one the toolbar put there, since nothing of the width a foreign document measured its own
+ * paper against would mean the same here.
+ *
+ * A table inside a cell is not read as a table, since the model only makes the outer one editable,
+ * and neither is one larger than the model holds. Both are read as their rows instead, so that a
+ * cell of the inner table still stands apart from the next one. A caption stands as the paragraph
+ * above whichever of the two the table is read as.
+ */
+export declare const tableBlockReader: HtmlBlockReader;
+/**
+ * A Word paragraph that is an item of a list, read as an item of a list here.
+ *
+ * Word puts no `<ul>` or `<ol>` on the clipboard: every item is a paragraph saying which list it
+ * belongs to, so the paragraphs of one list are joined by that name rather than by standing inside
+ * one element. Whether the list counts its items is only visible in the marker Word drew, which
+ * is taken out of the paragraph wherever it is: marked as a marker, or standing at the front of
+ * the content as anything else would.
+ */
+export declare const wordListReader: HtmlBlockReader;
+/** The readers every reading consults, in the order they are tried */
+export declare const DEFAULT_BLOCK_READERS: readonly HtmlBlockReader[];