@docx4j/core-ts 0.5.0 → 0.7.0

package/dist/model/text/commonmark.mjs

@@ -0,0 +1,655 @@
+// CR-012 phase 3: the Markdown writer docx4j's MarkdownExporter serializes with, a port of commonmark-java
+// 0.30.0's org.commonmark.renderer.markdown (MarkdownWriter, CoreMarkdownNodeRenderer) and of the Markdown
+// renderers of its GFM tables, strikethrough and footnotes extensions, with docx4j-markdown's math nodes
+// (org.docx4j.markdown.math.MathExtension's renderer). Only the nodes docx4j's WmlToMarkdown builds are here,
+// and each renders as commonmark-java renders it, so that this package's Markdown is docx4j's byte for byte.
+//
+// commonmark-java's licence, which its ported code keeps:
+//
+//   Copyright (c) 2015, Atlassian Pty Ltd
+//   All rights reserved.
+//
+//   Redistribution and use in source and binary forms, with or without
+//   modification, are permitted provided that the following conditions are met:
+//
+//   * Redistributions of source code must retain the above copyright notice, this
+//     list of conditions and the following disclaimer.
+//
+//   * Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+//   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+//   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+//   CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+//   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+//   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// ---------------------------------------------------------------- nodes (org.commonmark.node and the extensions')
+/** A node of the Markdown tree: its parent and children (commonmark-java `Node`). */
+export class MdNode {
+    constructor() {
+        this.children = [];
+    }
+    get firstChild() {
+        return this.children[0];
+    }
+    get lastChild() {
+        return this.children[this.children.length - 1];
+    }
+    get previous() {
+        var _a;
+        const siblings = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children;
+        return siblings === undefined ? undefined : siblings[siblings.indexOf(this) - 1];
+    }
+    get next() {
+        var _a;
+        const siblings = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children;
+        if (siblings === undefined)
+            return undefined;
+        const i = siblings.indexOf(this);
+        return i < 0 ? undefined : siblings[i + 1];
+    }
+    appendChild(child) {
+        child.unlink();
+        child.parent = this;
+        this.children.push(child);
+    }
+    prependChild(child) {
+        child.unlink();
+        child.parent = this;
+        this.children.unshift(child);
+    }
+    unlink() {
+        if (this.parent === undefined)
+            return;
+        const i = this.parent.children.indexOf(this);
+        if (i >= 0)
+            this.parent.children.splice(i, 1);
+        this.parent = undefined;
+    }
+}
+export class MdDocument extends MdNode {
+}
+export class MdParagraph extends MdNode {
+}
+export class MdBlockQuote extends MdNode {
+}
+export class MdHardLineBreak extends MdNode {
+}
+export class MdStrongEmphasis extends MdNode {
+}
+export class MdTableBlock extends MdNode {
+}
+export class MdTableHead extends MdNode {
+}
+export class MdTableBody extends MdNode {
+}
+export class MdTableRow extends MdNode {
+}
+export class MdHeading extends MdNode {
+    constructor(level) {
+        super();
+        this.level = level;
+    }
+}
+/** A bullet or ordered list: tight when its items are not separated by blank lines. */
+export class MdListBlock extends MdNode {
+    constructor() {
+        super(...arguments);
+        this.tight = true;
+    }
+}
+export class MdBulletList extends MdListBlock {
+}
+export class MdOrderedList extends MdListBlock {
+}
+export class MdListItem extends MdNode {
+}
+export class MdFencedCodeBlock extends MdNode {
+    constructor(literal) {
+        super();
+        this.literal = literal;
+    }
+}
+export class MdThematicBreak extends MdNode {
+    constructor(literal) {
+        super();
+        this.literal = literal;
+    }
+}
+export class MdHtmlInline extends MdNode {
+    constructor(literal) {
+        super();
+        this.literal = literal;
+    }
+}
+export class MdText extends MdNode {
+    constructor(literal) {
+        super();
+        this.literal = literal;
+    }
+}
+export class MdCode extends MdNode {
+    constructor(literal) {
+        super();
+        this.literal = literal;
+    }
+}
+export class MdEmphasis extends MdNode {
+}
+export class MdLink extends MdNode {
+    constructor(destination, title) {
+        super();
+        this.destination = destination;
+        this.title = title;
+    }
+}
+export class MdImage extends MdNode {
+    constructor(destination, title) {
+        super();
+        this.destination = destination;
+        this.title = title;
+    }
+}
+export class MdTableCell extends MdNode {
+    constructor(header) {
+        super();
+        this.header = header;
+    }
+}
+export class MdStrikethrough extends MdNode {
+    constructor(delimiter) {
+        super();
+        this.delimiter = delimiter;
+    }
+}
+export class MdFootnoteDefinition extends MdNode {
+    constructor(label) {
+        super();
+        this.label = label;
+    }
+}
+export class MdFootnoteReference extends MdNode {
+    constructor(label) {
+        super();
+        this.label = label;
+    }
+}
+/** Inline math, `$...$` (docx4j `InlineMath`). */
+export class MdInlineMath extends MdNode {
+    constructor(literal, displayHint) {
+        super();
+        this.literal = literal;
+        this.displayHint = displayHint;
+    }
+}
+/** Display math, a `$$` block (docx4j `DisplayMath`). */
+export class MdDisplayMath extends MdNode {
+    constructor(literal) {
+        super();
+        this.literal = literal;
+    }
+}
+const chars = (s) => new Set(s.split(''));
+class MarkdownWriter {
+    constructor(starts) {
+        this.starts = starts;
+        this.out = '';
+        this.blockSeparator = 0;
+        this.lastChar = '\u0000';
+        this.atLineStart = true;
+        this.prefixes = [];
+        this.tight = [];
+        this.rawEscapes = [];
+        /** Where the line being written starts in `out`. */
+        this.lineStart = 0;
+    }
+    raw(s) {
+        this.flushBlockSeparator();
+        this.write(s, undefined, true);
+    }
+    text(s, escape) {
+        if (s === '')
+            return;
+        this.flushBlockSeparator();
+        this.write(s, escape, true);
+    }
+    line() {
+        this.write('\n', undefined, false);
+        this.writePrefixes();
+        this.atLineStart = true;
+    }
+    block() {
+        this.blockSeparator = this.isTight() ? 1 : 2;
+        this.atLineStart = true;
+    }
+    pushPrefix(prefix) {
+        this.prefixes.push(prefix);
+    }
+    writePrefix(prefix) {
+        const tmp = this.atLineStart;
+        this.raw(prefix);
+        this.atLineStart = tmp;
+    }
+    popPrefix() {
+        this.prefixes.pop();
+    }
+    pushTight(tight) {
+        this.tight.push(tight);
+    }
+    popTight() {
+        this.tight.pop();
+    }
+    pushRawEscape(escape) {
+        this.rawEscapes.push(escape);
+    }
+    popRawEscape() {
+        this.rawEscapes.pop();
+    }
+    /**
+     * Writes `s`, escaping what `escape` and the raw escapes match. Content (`raw`, `text`) starts a pending
+     * tag at the line it is written on; line ends, prefixes and block separators never do.
+     */
+    write(s, escape, content) {
+        if (s === '') {
+            this.atLineStart = false;
+            return;
+        }
+        if (content && this.pendingTag !== undefined) {
+            if (!this.starts.has(this.pendingTag))
+                this.starts.set(this.pendingTag, this.lineStart);
+            this.pendingTag = undefined;
+        }
+        let chunk = s;
+        if (this.rawEscapes.length > 0 || escape !== undefined) {
+            chunk = '';
+            for (let i = 0; i < s.length; i++) {
+                const c = s.charAt(i);
+                if ((escape !== undefined && escape.has(c)) || this.rawEscapes.some((e) => e.has(c))) {
+                    chunk += c === '\n' ? '&#10;' : `\\${c}`; // a line end can't be escaped with \
+                }
+                else {
+                    chunk += c;
+                }
+            }
+        }
+        const newline = chunk.lastIndexOf('\n');
+        if (newline >= 0)
+            this.lineStart = this.out.length + newline + 1;
+        this.out += chunk;
+        this.lastChar = s.charAt(s.length - 1);
+        this.atLineStart = false;
+    }
+    writePrefixes() {
+        for (const prefix of this.prefixes)
+            this.write(prefix, undefined, false);
+    }
+    flushBlockSeparator() {
+        if (this.blockSeparator !== 0) {
+            this.write('\n', undefined, false);
+            this.writePrefixes();
+            if (this.blockSeparator > 1) {
+                this.write('\n', undefined, false);
+                this.writePrefixes();
+            }
+            this.blockSeparator = 0;
+        }
+    }
+    isTight() {
+        return this.tight.length > 0 && this.tight[this.tight.length - 1];
+    }
+}
+// ---------------------------------------------------------------- the renderer (CoreMarkdownNodeRenderer and the extensions')
+/**
+ * The characters escaped in text: commonmark-java's own, and the extensions' special characters as docx4j
+ * registers them (`|` the tables', `~` strikethrough's, `$` docx4j's math); `#` too in a heading.
+ */
+const TEXT_ESCAPE = chars('[]<>`*_&\n\\|~$');
+const TEXT_ESCAPE_IN_HEADING = chars('[]<>`*_&\n\\|~$#');
+const LINK_DESTINATION_NEEDS_ANGLE_BRACKETS = chars(' ()<>\n\\');
+const LINK_DESTINATION_ESCAPE_IN_ANGLE_BRACKETS = chars('<>\n\\');
+const LINK_TITLE_ESCAPE_IN_QUOTES = chars('"\n\\');
+const PIPE = chars('|');
+const ORDERED_LIST_MARKER = /^([0-9]{1,9})([.)])/;
+/**
+ * Renders a Markdown tree as commonmark-java's `MarkdownRenderer` does, with the tables, strikethrough,
+ * footnotes and docx4j math extensions. `starts` receives, for each node with a `tag`, the offset of the
+ * line its first character is written on.
+ */
+export function renderMarkdown(document, starts = new Map()) {
+    const r = new Renderer(new MarkdownWriter(starts));
+    r.render(document);
+    return r.writer.out;
+}
+class Renderer {
+    constructor(writer) {
+        this.writer = writer;
+        /** The current table's column alignments, from its header cells. */
+        this.columns = [];
+    }
+    render(node) {
+        const w = this.writer;
+        // a tag whose node wrote nothing gives way to the next; a tag starts once
+        const tagged = node.tag !== undefined && !w.starts.has(node.tag);
+        if (tagged)
+            w.pendingTag = node.tag;
+        this.renderNode(node);
+        if (tagged && w.pendingTag === node.tag)
+            w.pendingTag = undefined;
+    }
+    renderNode(node) {
+        var _a, _b, _c, _d, _e;
+        const w = this.writer;
+        if (node instanceof MdDocument) {
+            this.children(node);
+            w.line();
+        }
+        else if (node instanceof MdThematicBreak) {
+            w.raw((_a = node.literal) !== null && _a !== void 0 ? _a : '___'); // ___ isn't ambiguous with a list marker
+            w.block();
+        }
+        else if (node instanceof MdHeading) {
+            this.heading(node);
+        }
+        else if (node instanceof MdFencedCodeBlock) {
+            this.fencedCodeBlock(node);
+        }
+        else if (node instanceof MdParagraph) {
+            this.children(node);
+            w.block();
+        }
+        else if (node instanceof MdBlockQuote) {
+            w.writePrefix('> ');
+            w.pushPrefix('> ');
+            this.children(node);
+            w.popPrefix();
+            w.block();
+        }
+        else if (node instanceof MdBulletList || node instanceof MdOrderedList) {
+            w.pushTight(node.tight);
+            this.listHolder = node instanceof MdBulletList
+                ? { parent: this.listHolder, marker: (_b = node.marker) !== null && _b !== void 0 ? _b : '-', number: 0, delimiter: undefined }
+                : { parent: this.listHolder, marker: '', number: (_c = node.markerStartNumber) !== null && _c !== void 0 ? _c : 1, delimiter: (_d = node.markerDelimiter) !== null && _d !== void 0 ? _d : '.' };
+            this.children(node);
+            this.listHolder = this.listHolder.parent;
+            w.popTight();
+            w.block();
+        }
+        else if (node instanceof MdListItem) {
+            this.listItem(node);
+        }
+        else if (node instanceof MdCode) {
+            this.code(node.literal);
+        }
+        else if (node instanceof MdEmphasis) {
+            // nested emphasis takes the other delimiter
+            const delimiter = w.lastChar === '*' ? '_' : '*';
+            w.raw(delimiter);
+            this.children(node);
+            w.raw(delimiter);
+        }
+        else if (node instanceof MdStrongEmphasis) {
+            w.raw('**');
+            this.children(node);
+            w.raw('**');
+        }
+        else if (node instanceof MdLink) {
+            this.linkLike(node.title, node.destination, node, '[');
+        }
+        else if (node instanceof MdImage) {
+            this.linkLike(node.title, node.destination, node, '![');
+        }
+        else if (node instanceof MdHtmlInline) {
+            w.raw(node.literal);
+        }
+        else if (node instanceof MdHardLineBreak) {
+            w.raw('  ');
+            w.line();
+        }
+        else if (node instanceof MdText) {
+            this.text(node);
+        }
+        else if (node instanceof MdTableBlock) {
+            this.columns.length = 0;
+            w.pushTight(true);
+            this.children(node);
+            w.popTight();
+            w.block();
+        }
+        else if (node instanceof MdTableHead) {
+            this.children(node);
+            for (const alignment of this.columns) {
+                w.raw('|');
+                w.raw(alignment === 'LEFT' ? ':---' : alignment === 'RIGHT' ? '---:' : alignment === 'CENTER' ? ':---:' : '---');
+            }
+            w.raw('|');
+            w.block();
+        }
+        else if (node instanceof MdTableBody) {
+            this.children(node);
+        }
+        else if (node instanceof MdTableRow) {
+            this.children(node);
+            w.raw('|'); // the | at the end of the line
+            w.block();
+        }
+        else if (node instanceof MdTableCell) {
+            if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.parent) instanceof MdTableHead)
+                this.columns.push(node.alignment);
+            w.raw('|');
+            w.pushRawEscape(PIPE);
+            this.children(node);
+            w.popRawEscape();
+        }
+        else if (node instanceof MdStrikethrough) {
+            w.raw(node.delimiter);
+            this.children(node);
+            w.raw(node.delimiter);
+        }
+        else if (node instanceof MdFootnoteReference) {
+            w.raw('[^');
+            w.raw(node.label); // labels are written as they are
+            w.raw(']');
+        }
+        else if (node instanceof MdFootnoteDefinition) {
+            w.raw('[^');
+            w.raw(node.label);
+            w.raw(']: ');
+            w.pushPrefix('    ');
+            this.children(node);
+            w.popPrefix();
+        }
+        else if (node instanceof MdInlineMath) {
+            const delimiter = node.displayHint ? '$$' : '$';
+            w.raw(delimiter);
+            w.raw(node.literal.replace(/\n/g, ' '));
+            w.raw(delimiter);
+        }
+        else if (node instanceof MdDisplayMath) {
+            w.raw('$$');
+            w.line();
+            for (const line of node.literal.split('\n')) {
+                w.raw(line);
+                w.line();
+            }
+            w.raw('$$');
+            w.block();
+        }
+        else {
+            throw new Error(`No Markdown renderer for ${node.constructor.name}`);
+        }
+    }
+    children(parent) {
+        for (const child of [...parent.children])
+            this.render(child);
+    }
+    heading(heading) {
+        const w = this.writer;
+        if (heading.level <= 2 && hasLineBreak(heading)) {
+            // a Setext heading can have several lines, but only levels 1 and 2
+            this.children(heading);
+            w.line();
+            w.raw(heading.level === 1 ? '===' : '---');
+            w.block();
+            return;
+        }
+        w.raw('#'.repeat(heading.level));
+        w.raw(' ');
+        this.children(heading);
+        w.block();
+    }
+    fencedCodeBlock(code) {
+        const w = this.writer;
+        const literal = code.literal;
+        // a fence longer than any run of backticks in the code
+        const fence = '`'.repeat(Math.max(maxRunLength('`', literal) + 1, 3));
+        w.raw(fence);
+        w.line();
+        if (literal !== '') {
+            for (const line of linesOf(literal)) {
+                w.raw(line);
+                w.line();
+            }
+        }
+        w.raw(fence);
+        w.block();
+    }
+    listItem(item) {
+        const w = this.writer;
+        const holder = this.listHolder;
+        if (holder === undefined)
+            throw new Error('A list item outside a list');
+        let marker;
+        if (holder.delimiter === undefined) {
+            marker = holder.marker;
+        }
+        else {
+            marker = `${holder.number}${holder.delimiter}`;
+            holder.number++;
+        }
+        const spaces = ' ';
+        w.writePrefix(marker);
+        w.writePrefix(spaces);
+        w.pushPrefix(' '.repeat(marker.length + spaces.length));
+        if (item.firstChild === undefined) {
+            w.block(); // an empty item
+        }
+        else {
+            this.children(item);
+        }
+        w.popPrefix();
+    }
+    code(literal) {
+        const w = this.writer;
+        // backticks in the code: one more around it
+        const backticks = maxRunLength('`', literal);
+        w.raw('`'.repeat(backticks + 1));
+        // a space inside where the code starts or ends with a backtick, or starts and ends with a space
+        const addSpace = literal.startsWith('`') || literal.endsWith('`')
+            || (literal.startsWith(' ') && literal.endsWith(' ') && /[^ ]/.test(literal));
+        if (addSpace)
+            w.raw(' ');
+        w.raw(literal);
+        if (addSpace)
+            w.raw(' ');
+        w.raw('`'.repeat(backticks + 1));
+    }
+    text(text) {
+        // When in doubt, escape: a character special only at a line's start is escaped there alone.
+        const w = this.writer;
+        let literal = text.literal;
+        if (w.atLineStart && literal !== '') {
+            const c = literal.charAt(0);
+            if (c === '-') {
+                w.raw('\\-'); // a bullet list marker
+                literal = literal.substring(1);
+            }
+            else if (c === '#') {
+                w.raw('\\#'); // an ATX heading
+                literal = literal.substring(1);
+            }
+            else if (c === '=') {
+                if (text.previous !== undefined) { // a Setext heading, unless the block's first line
+                    w.raw('\\=');
+                    literal = literal.substring(1);
+                }
+            }
+            else if (c >= '0' && c <= '9') {
+                const m = ORDERED_LIST_MARKER.exec(literal);
+                if (m) {
+                    w.raw(m[1]);
+                    w.raw(`\\${m[2]}`);
+                    literal = literal.substring(m[0].length);
+                }
+            }
+            else if (c === '\t') {
+                w.raw('&#9;');
+                literal = literal.substring(1);
+            }
+            else if (c === ' ') {
+                w.raw('&#32;');
+                literal = literal.substring(1);
+            }
+        }
+        const escape = text.parent instanceof MdHeading ? TEXT_ESCAPE_IN_HEADING : TEXT_ESCAPE;
+        if (literal.endsWith('!') && text.next instanceof MdLink) {
+            // an unescaped ! would make the link an image
+            w.text(literal.substring(0, literal.length - 1), escape);
+            w.raw('\\!');
+        }
+        else {
+            w.text(literal, escape);
+        }
+    }
+    linkLike(title, destination, node, opener) {
+        const w = this.writer;
+        w.raw(opener);
+        this.children(node);
+        w.raw(']');
+        w.raw('(');
+        if ([...destination].some((c) => LINK_DESTINATION_NEEDS_ANGLE_BRACKETS.has(c))) {
+            w.raw('<');
+            w.text(destination, LINK_DESTINATION_ESCAPE_IN_ANGLE_BRACKETS);
+            w.raw('>');
+        }
+        else {
+            w.raw(destination);
+        }
+        if (title !== undefined) {
+            w.raw(' ');
+            w.raw('"');
+            w.text(title, LINK_TITLE_ESCAPE_IN_QUOTES);
+            w.raw('"');
+        }
+        w.raw(')');
+    }
+}
+function hasLineBreak(node) {
+    return node.children.some((c) => c instanceof MdHardLineBreak || hasLineBreak(c));
+}
+function maxRunLength(needle, s) {
+    let max = 0;
+    let pos = 0;
+    while (pos < s.length) {
+        pos = s.indexOf(needle, pos);
+        if (pos === -1)
+            return max;
+        let run = 0;
+        do {
+            pos += needle.length;
+            run++;
+        } while (s.startsWith(needle, pos));
+        max = Math.max(run, max);
+    }
+    return max;
+}
+/** A literal's lines, `\n` being a terminator: "abc\n" is one line. */
+function linesOf(literal) {
+    const parts = literal.split('\n');
+    return parts[parts.length - 1] === '' ? parts.slice(0, -1) : parts;
+}

package/dist/model/text/index.d.mts

@@ -0,0 +1,8 @@
+export { Texts } from './Texts.mjs';
+export { TextContext, PackageTrees, type TextPackage } from './TextContext.mjs';
+export { TextOptions, TextOptionError, TEXT_OPTION_NAMES, type TextOptionsInit, type TextModelView, type TextInclude, type TextFields, type TextBindings, type TextSymbols, type TextMath, type TextTables, type TextMarkupDetail, type TextLayout, type TextDropCaps, type TextSmallCaps, type TextRepair, type TextProfile, } from './TextOptions.mjs';
+export { TextResult, TextBlock, TextRun, TextRow, TextCell, TextField, TextNumbering, TextRevision, TextWarning, TextComment, TextImage, ImageDescription, AltTextDescriber, type ImageDescriber, type TextBlockKind, type TextStory, type TextRunKind, type NoteType, type TextRunSource, type TextVerticalAlignment, } from './TextResult.mjs';
+export { PlainText, INDENT_SPACES, LISTED_FORMAT_NOTE } from './PlainText.mjs';
+export { CaseMapping } from './CaseMapping.mjs';
+export { LinkTargets } from './LinkTargets.mjs';
+export { MarkdownExporter, MarkdownExportOptions, type MarkdownExportOptionsInit, type MarkdownImage, type MarkdownImageDestination, type MarkdownBlock, type MarkdownBlocks, } from './MarkdownExporter.mjs';

package/dist/model/text/index.mjs

@@ -0,0 +1,9 @@
+// The text model (CR-012): docx4j's org.docx4j.model.text, held to the text extraction specification.
+export { Texts } from './Texts.mjs';
+export { TextContext, PackageTrees } from './TextContext.mjs';
+export { TextOptions, TextOptionError, TEXT_OPTION_NAMES, } from './TextOptions.mjs';
+export { TextResult, TextBlock, TextRun, TextRow, TextCell, TextField, TextNumbering, TextRevision, TextWarning, TextComment, TextImage, ImageDescription, AltTextDescriber, } from './TextResult.mjs';
+export { PlainText, INDENT_SPACES, LISTED_FORMAT_NOTE } from './PlainText.mjs';
+export { CaseMapping } from './CaseMapping.mjs';
+export { LinkTargets } from './LinkTargets.mjs';
+export { MarkdownExporter, MarkdownExportOptions, } from './MarkdownExporter.mjs';

package/dist/model/text/normalize.d.mts

@@ -0,0 +1,8 @@
+/**
+ * WD REQ-1201's normalisation, under which texts are compared (`mce.branches_differ`, REQ-307; the
+ * conformance suite): CriticMarkup's delimiters, then white space (Java's `\s`, the six ASCII white-space
+ * characters, and `\p{Z}`), `*`, `_`, `\`, `{`, `}` and `$` removed. No Unicode normalisation: zero-width
+ * and tag characters, and the hyphens, are kept. JavaScript's `\s` would take U+FEFF too, so the
+ * characters are named.
+ */
+export declare function normalize(value: string | undefined | null): string;

package/dist/model/text/normalize.mjs

@@ -0,0 +1,13 @@
+// CR-012 phase 2: WD REQ-1201's normalisation, docx4j's `Texts.normalize`.
+/**
+ * WD REQ-1201's normalisation, under which texts are compared (`mce.branches_differ`, REQ-307; the
+ * conformance suite): CriticMarkup's delimiters, then white space (Java's `\s`, the six ASCII white-space
+ * characters, and `\p{Z}`), `*`, `_`, `\`, `{`, `}` and `$` removed. No Unicode normalisation: zero-width
+ * and tag characters, and the hyphens, are kept. JavaScript's `\s` would take U+FEFF too, so the
+ * characters are named.
+ */
+export function normalize(value) {
+    if (value === undefined || value === null)
+        return '';
+    return value.replace(/\{\+\+|\+\+\}|\{--|--\}|\{>>|<<\}/g, '').replace(/[\t\n\x0B\f\r\p{Z}*_\\{}$]/gu, '');
+}