@arbidocs/coedit 0.4.111 → 0.4.112

package/dist/commands.d.cts

@@ -1,163 +1,21 @@
+import { g as DocParagraph, k as ListItemInfo, j as LevelOf, R as ReferencesPort, a as CrossReferenceTarget, h as DocPoint, O as OoxmlNodeLike, b as DefinitionsPort, i as DocumentNumbering } from './port-ip7WByvH.cjs';
+export { B as BROKEN_CROSS_REFERENCE_STYLE, C as CROSS_REFERENCE_STYLE, D as DEFINED_TERM_STYLE, c as DocField, d as DocLink, e as DocMark, f as DocNote, F as FIELD_ATOM, L as LevelInfo, N as NumberingSource, W as WATCHED_STYLES, l as documentNumbering, m as filterTargets, n as listTargets, p as paragraphNumber, r as readParagraphs, s as styleNames } from './port-ip7WByvH.cjs';
 import { OoxmlProperty, TabStopWrite, TreeDocOp } from '@docx-editor.dev/core/store';
+import { R as Revision } from './track-eYC94jTp.cjs';
 
 /**
- * The read side of the Word-editor commands: a document's paragraphs as the commands see them
- * (text in the engine's offset vocabulary, bookmarks, internal links, fields, note references),
- * read from the engine's OOXML tree. The same tree comes from a live editor
- * (`surface.session.part().root`) or from document bytes (`openHeadlessDocument`), so the toolbar
- * and ARBI's headless tools read a document the same way.
- */
-/** Character style of an inserted term: a dotted underline, so a defined term reads as one. */
-declare const DEFINED_TERM_STYLE = "DefinedTerm";
-/** Character style of a cross-reference: a muted blue with a dotted underline (Word's name). */
-declare const CROSS_REFERENCE_STYLE = "CrossReference";
-/** Character style of a cross-reference whose target is gone: its last text, flagged. */
-declare const BROKEN_CROSS_REFERENCE_STYLE = "CrossReferenceBroken";
-/** A position: a paragraph (the engine's node id) and a UTF-16 offset into its text. */
-interface DocPoint {
-    paragraphId: string;
-    offset: number;
-}
-/** An internal link in a paragraph. */
-interface DocLink {
-    anchor: string;
-    text: string;
-    /** Where its text starts in the paragraph's text. */
-    offset?: number;
-}
-/** A footnote or endnote reference: one character of the paragraph, as the engine counts it. */
-interface DocNote {
-    offset: number;
-    kind: 'footnote' | 'endnote';
-    /** `w:id` of the note. */
-    id: string;
-}
-/** One paragraph, in document order. */
-interface DocParagraph {
-    id: string;
-    /** `w14:paraId`, the id that is the same in every replica of a collaboration room. */
-    paraId?: string;
-    text: string;
-    /** Styled as a heading (a `Heading n` style or an outline level). */
-    heading: boolean;
-    styleId?: string;
-    /** A paragraph of the body itself, not inside a table. */
-    topLevel: boolean;
-    /** Names of the bookmarks that start in it. */
-    bookmarks: string[];
-    /** Its internal links (`w:hyperlink w:anchor`). */
-    links: DocLink[];
-    /** Its complex fields: where each sits (its one-character offset), its instruction and result. */
-    fields?: DocField[];
-    /** Its runs in a watched character style (a broken cross-reference's mark), with their text. */
-    marks?: DocMark[];
-    /** Its footnote and endnote references. */
-    notes?: DocNote[];
-}
-/** A stretch of a paragraph's text in a watched character style. */
-interface DocMark {
-    styleId: string;
-    offset: number;
-    text: string;
-}
-/** Character styles whose runs a paragraph read reports as marks. */
-declare const WATCHED_STYLES: Set<string>;
-/** A complex field of a paragraph. */
-interface DocField {
-    offset: number;
-    instruction: string;
-    result: string;
-}
-type OoxmlNodeLike = {
-    id: string;
-    kind: string;
-    localName?: string;
-    value?: string;
-    attributes?: readonly {
-        localName: string;
-        value: string;
-    }[];
-    children?: readonly OoxmlNodeLike[];
-};
-/** How a field (or a note reference) counts in a paragraph's text (the engine's model vocabulary). */
-declare const FIELD_ATOM = "\uFFFC";
-/** The paragraphs of a part's body, read from the engine's OOXML tree. */
-declare function readParagraphs(root: OoxmlNodeLike): DocParagraph[];
-/** Style id to style name (`Heading1` → `heading 1`), from a styles part's tree. */
-declare function styleNames(root: OoxmlNodeLike | null | undefined): Map<string, string>;
-
-/**
- * Cross-reference targets: the document's numbered paragraphs (clauses, sub-clauses, numbered
- * captions) and its headings, with the number Word's `REF \r` shows for each.
+ * Cross-references, the way Word does them, and their status.
  *
- * The number is what the editor computes for a `REF … \r` field — and it has to be exactly that,
- * because the engine shows a field's live value only while the field's cached result matches what
- * it computes (otherwise it keeps the cached text for good). So this mirrors the engine: the
- * paragraph's own list level, preceded by each higher level whose number its level text does not
- * already show (`%1.%2` already shows level 1; `(%3)` does not show `2.1`), and one trailing
- * period dropped (`2.` reads `2`).
- */
-
-/** A paragraph's resolved list numbering (the engine's list item). */
-interface ListItemInfo {
-    numId: string;
-    ilvl: number;
-    markerText: string;
-    numFmt: string;
-}
-/** A list level's definition: its level text (`%1.%2`) and number format. */
-interface LevelInfo {
-    lvlText: string;
-    numFmt: string;
-}
-type LevelOf = (numId: string, ilvl: number) => LevelInfo | null;
-/**
- * The number `REF \r` shows for a paragraph, or null when it is not numbered. `order` is every
- * paragraph id in document order (for the markers of the levels above it).
- */
-declare function paragraphNumber(order: readonly string[], items: ReadonlyMap<string, ListItemInfo>, levelOf: LevelOf, paragraphId: string): string | null;
-/** One place a cross-reference can point at. */
-interface CrossReferenceTarget {
-    paragraphId: string;
-    /** A numbered paragraph (clause, sub-clause, caption) or an unnumbered heading. */
-    kind: 'numbered' | 'heading';
-    /** What `REF \r` shows (`8.2`), or null for an unnumbered heading. */
-    number: string | null;
-    /** The paragraph's list marker as painted (`8.2`, `(a)`), or empty. */
-    marker: string;
-    /** The paragraph's text (without its marker). */
-    text: string;
-    heading: boolean;
-    /** Its list level (0 for a top-level clause), or 0 for a heading. */
-    level: number;
-}
-/** Every numbered paragraph and every heading, in document order. */
-declare function listTargets(paragraphs: readonly DocParagraph[], items: ReadonlyMap<string, ListItemInfo>, levelOf: LevelOf): CrossReferenceTarget[];
-/** Targets whose number or text contains the query (case-insensitive). */
-declare function filterTargets(targets: readonly CrossReferenceTarget[], query: string): CrossReferenceTarget[];
-/** What the engine's numbering needs of a document: its parts' trees. */
-interface NumberingSource {
-    /** The main document part's root. */
-    root(): OoxmlNodeLike;
-    stylesRoot(): unknown;
-    numberingRoot(): unknown;
-    settingsRoot(): unknown;
-}
-/** A document's list numbering as the engine resolves it. */
-interface DocumentNumbering {
-    /** Each numbered paragraph's list item, by paragraph (node) id. */
-    listItems(): ReadonlyMap<string, ListItemInfo>;
-    levelOf: LevelOf;
-}
-/**
- * The numbering of a document, as the editor paints it: from a live editor's session or from a
- * headless document view alike.
- */
-declare function documentNumbering(source: NumberingSource): DocumentNumbering;
-
-/**
- * The cross-references of a document (`REF` fields to `_Ref` bookmarks), each with what it shows
- * and what its target now is: current, stale (a clause renumbered, a heading reworded) or broken
+ * Within the document: a hidden `_Ref…` bookmark on the target paragraph and a `REF` field at the
+ * caret — `REF _Ref123 \\r \\h` for a numbered paragraph (Word's Cross-reference › Numbered item ›
+ * Paragraph number), `REF _Ref123 \\h` for a heading's text. The field's cached result is the value
+ * the editor computes, so it updates live when the clauses are renumbered, and Word updates it
+ * with the document's other fields.
+ *
+ * To another document: a hyperlink with the reference text ("SPA, clause 8.2"), aimed at the app
+ * address of that document's passage (so it works from Word too), with a screen tip saying so.
+ *
+ * Every cross-reference reads as current, stale (a clause renumbered, a heading reworded) or broken
  * (the target is gone).
  */
 
@@ -214,6 +72,82 @@ declare function crossReferences(port: ReferencesReader): CrossReference[];
 declare function staleCrossReferences(port: ReferencesReader): StaleReference[];
 /** The broken cross-references marked in the document, in document order. */
 declare function brokenCrossReferences(port: Pick<ReferencesReader, 'paragraphs'>): BrokenReference[];
+/** A new `_Ref` bookmark name: Word's shape (`_Ref` and nine digits), not yet in the document. */
+declare function newRefBookmark(taken: ReadonlySet<string>, random?: () => number): string;
+/**
+ * A complex `REF` field with its cached result, every run in the Cross Reference style (Word gives
+ * an updated result the formatting of the field's first run).
+ */
+declare function refFieldXml(instruction: string, cached: string): string;
+/** The screen tip of a reference to this document: "Cross-reference to clause 2.2". */
+declare const refTooltip: (value: string, mode: CrossReferenceMode) => string;
+/**
+ * A reference to this document: the `REF` field inside a link to the same bookmark, which carries
+ * the screen tip Word shows on hover ("Cross-reference to clause 2.2").
+ */
+declare function crossReferenceXml(bookmark: string, mode: CrossReferenceMode, value: string): string;
+/** The field instruction for a target: its paragraph number, or its text. */
+declare const refInstruction: (bookmark: string, mode: CrossReferenceMode) => string;
+/** What the reference reads in the text. */
+declare const refResult: (target: CrossReferenceTarget, mode: CrossReferenceMode) => string;
+/**
+ * The `_Ref` bookmark a target carries: an existing one at the paragraph, else a new one. For a
+ * paragraph number it is an empty bookmark at the paragraph's start (the number is the
+ * paragraph's); for heading text it wraps the heading's runs (REF shows the bookmarked text).
+ */
+declare function ensureTargetBookmark(port: ReferencesPort, target: CrossReferenceTarget, mode: CrossReferenceMode): string;
+/**
+ * Mark a cross-reference's target (see {@link ensureTargetBookmark}): what the reference will
+ * address and read. A paragraph number falls back to the heading text when it has none. Done as a
+ * direct edit even while suggesting — the bookmark is hidden, and a heading's text is put back as
+ * it was — so rejecting the reference leaves the target as it was.
+ */
+declare function markCrossReferenceTarget(port: ReferencesPort, target: CrossReferenceTarget, mode: CrossReferenceMode): {
+    bookmark: string;
+    mode: CrossReferenceMode;
+    value: string;
+};
+/**
+ * Insert the `REF` field of a marked target at `caret`; the caret ends after it. With a port
+ * whose pastes are tracked, the reference is one suggestion.
+ */
+declare function insertCrossReferenceField(port: ReferencesPort, { bookmark, mode, value }: {
+    bookmark: string;
+    mode: CrossReferenceMode;
+    value: string;
+}, caret: DocPoint): {
+    bookmark: string;
+};
+/** Insert a cross-reference to a target of this document at `caret`; the caret ends after it. */
+declare function insertCrossReference(port: ReferencesPort, target: CrossReferenceTarget, mode: CrossReferenceMode, caret: DocPoint): {
+    bookmark: string;
+};
+/** The screen tip of a reference to another document: "Cross-reference: SPA, clause 8.2 — opens in ARBI". */
+declare const documentReferenceTooltip: (text: string, appName?: string) => string;
+/**
+ * Insert a reference to another document's passage: the reference text in the Cross Reference
+ * style, linked to the passage's (absolute) app address, at `caret`.
+ */
+declare function insertDocumentReference(port: ReferencesPort, reference: {
+    text: string;
+    url: string;
+    appName?: string;
+}, caret: DocPoint): void;
+interface RefreshResult {
+    /** References rewritten with their current number or text. */
+    refreshed: number;
+    /** References whose target is gone, now (or already) marked broken. */
+    broken: BrokenReference[];
+}
+/**
+ * Bring every cross-reference up to date: a stale one is replaced by the same reference with its
+ * current value (and screen tip); one whose target was deleted becomes its last text in the Cross
+ * Reference Broken style — never Word's "Error! Reference source not found." A field directly
+ * after another field is left alone: a paste there would land inside the previous field.
+ */
+declare function refreshCrossReferences(port: ReferencesPort): RefreshResult;
+/** A paragraph's runs as XML (formatting kept), or null for anything but plain runs. */
+declare function paragraphRunsXml(paragraph: OoxmlNodeLike): string | null;
 
 /**
  * Undo for the changes ARBI applies directly (they cannot be tracked): a paragraph style or format,
@@ -293,11 +227,181 @@ declare function fieldNodeIds(paragraph: OoxmlNodeLike): string[];
  */
 declare function undoOps(root: OoxmlNodeLike, record: UndoRecord): TreeDocOp[] | null;
 
+/**
+ * The minimal WordprocessingML a command writes: escaped text, a `word/document.xml` and
+ * `word/styles.xml` around it, and the `.docx` package that carries them (a paste fragment).
+ */
+declare const W_NAMESPACES = "xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"";
+/** Text as XML character data or an attribute value. */
+declare const esc: (text: string) => string;
+/** A `word/document.xml` around body content (paragraphs, tables, then the section). */
+declare const documentXml: (body: string) => string;
+/** `word/styles.xml` holding the given style definitions. */
+declare const stylesXml: (defaults: string, styles: string) => string;
+/** A relationship to an external hyperlink target, for `w:hyperlink r:id`. */
+declare const hyperlinkRelationship: (id: string, url: string) => string;
+/** The minimal `.docx` package: a document, its styles, and its title and time. */
+declare function docxPackage(parts: {
+    document: string;
+    styles: string;
+    title: string;
+    /** ISO time; default now. */
+    at?: string;
+    /** Further `word/document.xml` relationships (e.g. {@link hyperlinkRelationship}). */
+    relationships?: string;
+}): Uint8Array;
+
+/**
+ * Defined terms in text: a definition's term read from the start of its text (`"Shares" means …`,
+ * `**Business Day** shall mean …`, `Completion: the date …`), the order of a glossary, and the hidden
+ * Word bookmark a term links to. Shared by the editor's Defined Terms and ARBI's headless tools.
+ */
+/** A definition's text split into its term and the rest. */
+interface ParsedDefinition {
+    /** The term as written, without quotes or emphasis (`Business Day`). */
+    term: string;
+    /** What follows the term, its connecting word included (`means a day …`, `: the date …`). */
+    rest: string;
+    /** Just the meaning, the connecting word dropped (`a day …`). */
+    meaning: string;
+}
+/** A definition as the commands insert it: the id of its fact, its term and the rest. */
+interface DefinitionText extends Pick<ParsedDefinition, 'term' | 'rest'> {
+    id: string;
+}
+/** The matching key of a term: case and whitespace folded, quotes and emphasis dropped. */
+declare function termKey(term: string): string;
+/**
+ * Read a definition's term from the start of its text, or `null` when it does not start with one.
+ *
+ * Optional straight or curly quotes and bold markers around the term are dropped; the term is what
+ * comes before "means", "shall mean", "includes", "has the meaning", a colon, or a dash. A quoted
+ * term is taken whole, so `"Long-Stop Date" means …` keeps its hyphen.
+ */
+declare function parseDefinition(text: string): ParsedDefinition | null;
+/** Alphabetical order of terms, as a reader sorts a glossary (case and accents folded). */
+declare const compareTerms: (a: string, b: string) => number;
+/** Prefix of every bookmark a defined term links to: hidden in Word (leading underscore). */
+declare const DEFINITION_BOOKMARK_PREFIX = "_dt_";
+/**
+ * The Word bookmark of a definition: `_dt_` and the fact id in valid bookmark characters
+ * (`fct-AbC12345` → `_dt_fct_AbC12345`), at most 40 characters as Word requires.
+ */
+declare function definitionBookmark(factId: string): string;
+/** The fact id a definition bookmark names, or `null` for any other bookmark. */
+declare function definitionIdOfBookmark(name: string): string | null;
+
+/**
+ * Defined-term and cross-reference content as WordprocessingML, and the clipboard fragment (a small
+ * `.docx` package) that carries it into a document. The engine has no "insert bookmark" command, but
+ * its paste lands an embedded fragment with everything in it — `w:bookmarkStart`/`w:bookmarkEnd` and
+ * `w:hyperlink w:anchor` included — freshening bookmark ids as it goes.
+ */
+
+type Definition$1 = Pick<ParsedDefinition, 'term' | 'rest'>;
+/**
+ * The character styles the inserted content uses. A paste brings a style the document does not
+ * define; one it already defines (a house template's) is used as it is, so only the missing ones
+ * go into a fragment (see {@link stylesUsed}).
+ */
+declare const CHARACTER_STYLES: Record<string, string>;
+/** The character styles a fragment's runs use (`w:rStyle`), as ids. */
+declare function stylesUsed(body: string): string[];
+/** What Word shows on hover over a term: its definition, as one line of at most 255 characters. */
+declare function definitionTooltip(definition: Definition$1): string;
+/** The definition paragraph's text as the document shows it: `“Shares” means the issued shares.` */
+declare const definitionParagraphText: (definition: Definition$1) => string;
+/**
+ * A definition paragraph: the quoted term in bold, bookmarked (`bookmark`), then the definition as
+ * the fact writes it. `id` is the bookmark id inside the fragment; the paste renumbers it.
+ */
+declare function definitionParagraphXml(definition: Definition$1, bookmark: string, id?: number): string;
+/** A heading paragraph: the document's own heading style when it has one, else bold text. */
+declare function headingParagraphXml(text: string, styleId?: string): string;
+/** The term as an internal link to its definition's bookmark, with the definition as its tooltip. */
+declare function termLinkXml(term: string, bookmark: string, tooltip: string): string;
+/**
+ * The fragment package carrying `body` (paragraph XML). `covered` says the last paragraph mark is
+ * part of it: the paste then ends with a whole paragraph (a block inserted before the caret's
+ * paragraph) instead of running into the text after the caret (inline). With a `revision`, the
+ * fragment is one tracked insertion by it.
+ */
+declare function fragmentPackage(body: string, covered: boolean, { revision, relationships, styles, }?: {
+    revision?: Revision | null;
+    /** Relationships the body refers to (a hyperlink's target). */
+    relationships?: string;
+    /** The character styles to bring (default: every one the body uses). */
+    styles?: readonly string[];
+}): Uint8Array;
+/** The style ids a document's styles part defines. */
+declare function documentStyleIds(root: OoxmlNodeLike | null | undefined): Set<string>;
+
+/**
+ * The defined-term commands: insert a term as a link to its definition (adding the definition to
+ * the document's Definitions section when it is not there yet). Written against
+ * {@link DefinitionsPort}, so they run on the live editor and on the in-memory model the tests use
+ * alike.
+ *
+ * Where the Definitions section is: the first top-level paragraph titled "Definitions",
+ * "Definitions and interpretation", "Interpretation", "Defined terms" or "Glossary" (clause numbers
+ * ignored), up to the next heading. A document without one gets a "Definitions" heading at its end:
+ * appended, it never splits the clause being drafted, and it is where a reader of a draft looks
+ * for a schedule of terms. Inside the section, definitions are kept in alphabetical order.
+ */
+
+type Definition = DefinitionText;
+/** Title of a Definitions section the commands create. */
+declare const DEFINITIONS_HEADING = "Definitions";
+/** Whether a paragraph titles a Definitions section. */
+declare function isDefinitionsTitle(paragraph: DocParagraph): boolean;
+/** The Definitions section: its title's index and the paragraphs after it, up to the next heading. */
+interface DefinitionsSection {
+    title: number;
+    /** First paragraph after the title. */
+    start: number;
+    /** Index after the section's last paragraph (the next heading, a table, or the end). */
+    end: number;
+}
+declare function findDefinitionsSection(paragraphs: readonly DocParagraph[]): DefinitionsSection | null;
+/**
+ * Where a definition of `term` goes in the section, alphabetically: before the first definition
+ * whose term sorts after it, else after the last definition (else right after the title).
+ */
+declare function insertionIndex(paragraphs: readonly DocParagraph[], section: DefinitionsSection, term: string, skip?: ReadonlySet<string>): number;
+/**
+ * Add a definition paragraph to the Definitions section (made at the end of the document when there
+ * is none), in alphabetical order. Answers where `keep` moved to.
+ */
+declare function addDefinition(port: DefinitionsPort, definition: Definition, keep?: DocPoint): DocPoint | undefined;
+interface InsertTermResult {
+    /** The definition was not in the document yet and was added to its Definitions section. */
+    addedDefinition: boolean;
+}
+/**
+ * Insert a defined term at the caret: the term as an internal link to its definition's bookmark
+ * (its definition as the link's tooltip), the definition added to the Definitions section first
+ * when the document does not have it. `replace` characters before the caret (a typed `@@query`)
+ * are removed first. The caret ends after the term.
+ */
+declare function insertDefinedTerm(port: DefinitionsPort, definition: Definition, options?: {
+    replace?: number;
+}): InsertTermResult;
+/** Term groups keyed for quick lookup of the definition a bookmark points at. */
+declare function definitionsById<D extends Definition>(definitions: readonly D[]): Map<string, D>;
+/** The definition an internal link points at, from its bookmark name. */
+declare function definitionOfAnchor<D extends Definition>(anchor: string, definitions: ReadonlyMap<string, D>): D | undefined;
+
 /** A document's parts as trees: a live editor's session or a headless view (`openHeadlessDocument`). */
 interface DocumentTrees {
     part(): {
         root: unknown;
     };
+    /** The package, for its notes parts (absent on a live editor's session). */
+    currentPackage?(): {
+        parts: ReadonlyMap<string, {
+            root: unknown;
+        }>;
+    };
     stylesRoot(): unknown;
     numberingRoot(): unknown;
     settingsRoot(): unknown;
@@ -306,10 +410,12 @@ interface DocumentTrees {
 interface DocumentReader extends ReferencesReader, DocumentNumbering {
     /** A style's name (`heading 1`) by its id, or the id when the document does not name it. */
     styleName(styleId: string): string;
+    /** A footnote's or endnote's text by its `w:id`. */
+    noteText(kind: 'footnote' | 'endnote', id: string): string | undefined;
 }
 /** Read a document whose trees do not change while the reader is used (a headless view). */
 declare function documentReader(view: DocumentTrees): DocumentReader;
 /** Read a document from its bytes (a collaboration room's `readRoom`). Throws on a bad package. */
 declare function readDocument(bytes: Uint8Array): DocumentReader;
 
-export { AGENT_UNDO_MAP, BROKEN_CROSS_REFERENCE_STYLE, type BrokenReference, CROSS_REFERENCE_STYLE, type CrossReference, type CrossReferenceMode, type CrossReferenceTarget, DEFINED_TERM_STYLE, type DocField, type DocLink, type DocMark, type DocNote, type DocParagraph, type DocPoint, type DocumentNumbering, type DocumentReader, type DocumentTrees, FIELD_ATOM, type LevelInfo, type LevelOf, type ListItemInfo, type NumberingSource, type OoxmlNodeLike, type ParagraphState, REF_BOOKMARK_PREFIX, type ReferencesReader, type SectionState, type StaleReference, type UndoRecord, WATCHED_STYLES, brokenCrossReferences, crossReferences, documentNumbering, documentReader, fieldNodeIds, filterTargets, listTargets, paragraphIndex, paragraphNumber, paragraphState, readDocument, readParagraphs, sectionStates, staleCrossReferences, styleNames, tableOf, tableState, undoOps };
+export { AGENT_UNDO_MAP, type BrokenReference, CHARACTER_STYLES, type CrossReference, type CrossReferenceMode, CrossReferenceTarget, DEFINITIONS_HEADING, DEFINITION_BOOKMARK_PREFIX, type DefinitionText, DefinitionsPort, type DefinitionsSection, DocParagraph, DocPoint, DocumentNumbering, type DocumentReader, type DocumentTrees, type InsertTermResult, LevelOf, ListItemInfo, OoxmlNodeLike, type ParagraphState, type ParsedDefinition, REF_BOOKMARK_PREFIX, ReferencesPort, type ReferencesReader, type RefreshResult, type SectionState, type StaleReference, type UndoRecord, W_NAMESPACES, addDefinition, brokenCrossReferences, compareTerms, crossReferenceXml, crossReferences, definitionBookmark, definitionIdOfBookmark, definitionOfAnchor, definitionParagraphText, definitionParagraphXml, definitionTooltip, definitionsById, documentReader, documentReferenceTooltip, documentStyleIds, documentXml, docxPackage, ensureTargetBookmark, esc, fieldNodeIds, findDefinitionsSection, fragmentPackage, headingParagraphXml, hyperlinkRelationship, insertCrossReference, insertCrossReferenceField, insertDefinedTerm, insertDocumentReference, insertionIndex, isDefinitionsTitle, markCrossReferenceTarget, newRefBookmark, paragraphIndex, paragraphRunsXml, paragraphState, parseDefinition, readDocument, refFieldXml, refInstruction, refResult, refTooltip, refreshCrossReferences, sectionStates, staleCrossReferences, stylesUsed, stylesXml, tableOf, tableState, termKey, termLinkXml, undoOps };