docxmlater 10.4.0 → 11.0.4

package/dist/esm/elements/Field.js

@@ -0,0 +1,856 @@
+import { parseHyperlinkInstruction, isHyperlinkInstruction, } from './FieldHelpers.js';
+import { pointsToHalfPoints } from '../utils/units.js';
+export class Field {
+    type;
+    instruction;
+    formatting;
+    fldLock;
+    dirty;
+    constructor(properties) {
+        this.type = properties.type;
+        this.formatting = properties.formatting;
+        this.fldLock = properties.fldLock;
+        this.dirty = properties.dirty;
+        if (properties.instruction) {
+            this.instruction = properties.instruction;
+        }
+        else {
+            this.instruction = this.buildInstruction(properties);
+        }
+    }
+    buildInstruction(properties) {
+        let instruction = properties.type;
+        if (properties.dateFormat && this.isDateField(properties.type)) {
+            instruction += ` \\@ "${properties.dateFormat}"`;
+        }
+        if (properties.format) {
+            instruction += ` ${properties.format}`;
+        }
+        else if (properties.preserveFormatting !== false) {
+            instruction += ' \\* MERGEFORMAT';
+        }
+        return instruction;
+    }
+    isDateField(type) {
+        return ['DATE', 'TIME', 'CREATEDATE', 'SAVEDATE', 'PRINTDATE'].includes(type);
+    }
+    getType() {
+        return this.type;
+    }
+    getInstruction() {
+        return this.instruction;
+    }
+    setFormatting(formatting) {
+        this.formatting = formatting;
+        return this;
+    }
+    getFormatting() {
+        return this.formatting;
+    }
+    isHyperlinkField() {
+        return (this.type === 'HYPERLINK' || this.instruction.trim().toUpperCase().startsWith('HYPERLINK'));
+    }
+    setColor(color) {
+        if (!this.formatting) {
+            this.formatting = {};
+        }
+        this.formatting.color = color.replace('#', '');
+        return this;
+    }
+    toXML() {
+        const runChildren = [];
+        if (this.formatting) {
+            runChildren.push(this.createRunProperties());
+        }
+        runChildren.push({
+            name: 'w:t',
+            attributes: { 'xml:space': 'preserve' },
+            children: [this.getPlaceholderText()],
+        });
+        const fldSimpleAttrs = {
+            'w:instr': this.instruction,
+        };
+        if (this.fldLock !== undefined) {
+            fldSimpleAttrs['w:fldLock'] = this.fldLock ? '1' : '0';
+        }
+        if (this.dirty !== undefined) {
+            fldSimpleAttrs['w:dirty'] = this.dirty ? '1' : '0';
+        }
+        return {
+            name: 'w:fldSimple',
+            attributes: fldSimpleAttrs,
+            children: [
+                {
+                    name: 'w:r',
+                    children: runChildren,
+                },
+            ],
+        };
+    }
+    getPlaceholderText() {
+        switch (this.type) {
+            case 'PAGE':
+                return '1';
+            case 'NUMPAGES':
+                return '1';
+            case 'SECTIONPAGES':
+                return '1';
+            case 'SECTION':
+                return '1';
+            case 'DATE':
+                return new Date().toLocaleDateString();
+            case 'TIME':
+                return new Date().toLocaleTimeString();
+            case 'CREATEDATE':
+            case 'SAVEDATE':
+            case 'PRINTDATE':
+                return new Date().toLocaleDateString();
+            case 'FILENAME':
+                return 'Document';
+            case 'FILENAMEWITHPATH':
+                return 'C:\\Document.docx';
+            case 'AUTHOR':
+                return 'Author';
+            case 'TITLE':
+                return 'Title';
+            case 'SUBJECT':
+                return 'Subject';
+            case 'KEYWORDS':
+                return 'Keywords';
+            case 'REF':
+                return '1';
+            case 'HYPERLINK':
+                return 'Link';
+            case 'SEQ':
+                return '1';
+            case 'TC':
+                return '';
+            case 'XE':
+                return '';
+            default:
+                return '';
+        }
+    }
+    createRunProperties() {
+        const children = [];
+        if (!this.formatting) {
+            return { name: 'w:rPr', children };
+        }
+        if (this.formatting.font) {
+            children.push({
+                name: 'w:rFonts',
+                attributes: {
+                    'w:ascii': this.formatting.font,
+                    'w:hAnsi': this.formatting.font,
+                    'w:cs': this.formatting.font,
+                },
+                selfClosing: true,
+            });
+        }
+        if (this.formatting.bold) {
+            children.push({ name: 'w:b', selfClosing: true });
+        }
+        if (this.formatting.italic) {
+            children.push({ name: 'w:i', selfClosing: true });
+        }
+        if (this.formatting.strike) {
+            children.push({ name: 'w:strike', selfClosing: true });
+        }
+        if (this.formatting.color) {
+            const color = this.formatting.color.replace('#', '');
+            children.push({
+                name: 'w:color',
+                attributes: { 'w:val': color },
+                selfClosing: true,
+            });
+        }
+        if (this.formatting.size) {
+            const sizeValue = pointsToHalfPoints(this.formatting.size).toString();
+            children.push({
+                name: 'w:sz',
+                attributes: { 'w:val': sizeValue },
+                selfClosing: true,
+            });
+            children.push({
+                name: 'w:szCs',
+                attributes: { 'w:val': sizeValue },
+                selfClosing: true,
+            });
+        }
+        if (this.formatting.highlight) {
+            children.push({
+                name: 'w:highlight',
+                attributes: { 'w:val': this.formatting.highlight },
+                selfClosing: true,
+            });
+        }
+        if (this.formatting.underline) {
+            const val = typeof this.formatting.underline === 'string' ? this.formatting.underline : 'single';
+            children.push({
+                name: 'w:u',
+                attributes: { 'w:val': val },
+                selfClosing: true,
+            });
+        }
+        return { name: 'w:rPr', children };
+    }
+    static createPageNumber(formatting) {
+        return new Field({
+            type: 'PAGE',
+            formatting,
+        });
+    }
+    static createTotalPages(formatting) {
+        return new Field({
+            type: 'NUMPAGES',
+            formatting,
+        });
+    }
+    static createDate(format, formatting) {
+        return new Field({
+            type: 'DATE',
+            dateFormat: format,
+            formatting,
+        });
+    }
+    static createTime(format, formatting) {
+        return new Field({
+            type: 'TIME',
+            dateFormat: format,
+            formatting,
+        });
+    }
+    static createFilename(includePath = false, formatting) {
+        return new Field({
+            type: includePath ? 'FILENAMEWITHPATH' : 'FILENAME',
+            formatting,
+        });
+    }
+    static createAuthor(formatting) {
+        return new Field({
+            type: 'AUTHOR',
+            formatting,
+        });
+    }
+    static createTitle(formatting) {
+        return new Field({
+            type: 'TITLE',
+            formatting,
+        });
+    }
+    static createSectionPages(formatting) {
+        return new Field({
+            type: 'SECTIONPAGES',
+            formatting,
+        });
+    }
+    static createRef(bookmark, format, formatting) {
+        const formatSwitch = format || '\\h';
+        const instruction = `REF ${bookmark} ${formatSwitch} \\* MERGEFORMAT`;
+        return new Field({
+            type: 'REF',
+            instruction,
+            formatting,
+        });
+    }
+    static createHyperlink(url, _displayText = url, tooltip, formatting) {
+        let instruction = `HYPERLINK "${url}"`;
+        if (tooltip) {
+            instruction += ` \\o "${tooltip}"`;
+        }
+        instruction += ' \\* MERGEFORMAT';
+        return new Field({
+            type: 'HYPERLINK',
+            instruction,
+            formatting,
+        });
+    }
+    static createSeq(identifier, format, formatting) {
+        let instruction = `SEQ ${identifier}`;
+        if (format) {
+            instruction += ` ${format}`;
+        }
+        else {
+            instruction += ' \\* ARABIC';
+        }
+        instruction += ' \\* MERGEFORMAT';
+        return new Field({
+            type: 'SEQ',
+            instruction,
+            formatting,
+        });
+    }
+    static createTCEntry(text, level = 1, formatting) {
+        if (level < 1 || level > 9) {
+            throw new Error('TC level must be between 1 and 9');
+        }
+        const instruction = `TC "${text}" \\f C \\l ${level}`;
+        return new Field({
+            type: 'TC',
+            instruction,
+            formatting,
+        });
+    }
+    static createXEEntry(text, subEntry, formatting) {
+        let instruction = `XE "${text}"`;
+        if (subEntry) {
+            instruction += `:${subEntry}`;
+        }
+        return new Field({
+            type: 'XE',
+            instruction,
+            formatting,
+        });
+    }
+    static createCustom(instruction, formatting) {
+        return new Field({
+            type: 'PAGE',
+            instruction,
+            formatting,
+        });
+    }
+    static create(properties) {
+        return new Field(properties);
+    }
+}
+export class ComplexField {
+    instruction;
+    result;
+    instructionFormatting;
+    resultFormatting;
+    nestedFields;
+    resultContent;
+    multiParagraph;
+    parsedHyperlink;
+    resultRevisions = [];
+    _hasResultSection = false;
+    _formFieldData;
+    trackingContext;
+    constructor(properties) {
+        this.instruction = properties.instruction;
+        this.result = properties.result;
+        this.instructionFormatting = properties.instructionFormatting;
+        this.resultFormatting = properties.resultFormatting;
+        this.nestedFields = properties.nestedFields || [];
+        this.resultContent = properties.resultContent || [];
+        this.multiParagraph = properties.multiParagraph || false;
+        this._hasResultSection = properties.hasResult ?? false;
+        this._formFieldData = properties.formFieldData;
+        if (properties.parsedHyperlink) {
+            this.parsedHyperlink = properties.parsedHyperlink;
+        }
+        else if (isHyperlinkInstruction(this.instruction)) {
+            this.parsedHyperlink = parseHyperlinkInstruction(this.instruction) || undefined;
+        }
+    }
+    getInstruction() {
+        return this.instruction;
+    }
+    setInstruction(instruction) {
+        this.instruction = instruction;
+        return this;
+    }
+    getFormFieldData() {
+        return this._formFieldData;
+    }
+    getResult() {
+        return this.result;
+    }
+    setResult(result) {
+        this.result = result;
+        this.resultRevisions = [];
+        this.resultContent = [];
+        return this;
+    }
+    hasResultSection() {
+        return this._hasResultSection;
+    }
+    setInstructionFormatting(formatting) {
+        this.instructionFormatting = formatting;
+        return this;
+    }
+    setResultFormatting(formatting) {
+        this.resultFormatting = formatting;
+        return this;
+    }
+    getParsedHyperlink() {
+        return this.parsedHyperlink;
+    }
+    isHyperlinkField() {
+        return this.parsedHyperlink !== undefined;
+    }
+    getHyperlinkUrl() {
+        return this.parsedHyperlink?.fullUrl;
+    }
+    addNestedField(field) {
+        this.nestedFields.push(field);
+        return this;
+    }
+    getNestedFields() {
+        return [...this.nestedFields];
+    }
+    removeNestedField(index) {
+        if (index < 0 || index >= this.nestedFields.length) {
+            return false;
+        }
+        this.nestedFields.splice(index, 1);
+        return true;
+    }
+    getNestedFieldCount() {
+        return this.nestedFields.length;
+    }
+    clearNestedFields() {
+        this.nestedFields = [];
+        return this;
+    }
+    updateInstruction(instruction) {
+        this.instruction = instruction;
+        return this;
+    }
+    addResultContent(content) {
+        this.resultContent.push(content);
+        return this;
+    }
+    getResultContent() {
+        return [...this.resultContent];
+    }
+    _setTrackingContext(context) {
+        this.trackingContext = context;
+    }
+    getAcceptedResultText() {
+        if (this.resultContent.length === 0) {
+            return this.result || '';
+        }
+        let text = '';
+        for (const element of this.resultContent) {
+            if (element.name === 'w:r') {
+                text += this.extractTextFromRunXml(element);
+            }
+            else if (element.name === 'w:ins') {
+                for (const child of element.children || []) {
+                    if (typeof child !== 'string' && child.name === 'w:r') {
+                        text += this.extractTextFromRunXml(child);
+                    }
+                }
+            }
+        }
+        return text || this.result || '';
+    }
+    extractTextFromRunXml(run) {
+        let text = '';
+        for (const child of run.children || []) {
+            if (typeof child !== 'string' && (child.name === 'w:t' || child.name === 'w:delText')) {
+                for (const t of child.children || []) {
+                    if (typeof t === 'string')
+                        text += t;
+                }
+            }
+        }
+        return text;
+    }
+    setTrackedResult(newText, author, options) {
+        const currentText = this.getAcceptedResultText();
+        if (currentText === newText)
+            return this;
+        const date = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+        let delId, insId;
+        if (this.trackingContext) {
+            const rm = this.trackingContext.getRevisionManager();
+            delId = rm.consumeNextId();
+            insId = rm.consumeNextId();
+        }
+        else {
+            const base = Date.now() % 100000000;
+            delId = base;
+            insId = base + 1;
+        }
+        let rPr = null;
+        if (options?.formatting) {
+            rPr = this.createRunProperties(options.formatting);
+        }
+        else if (options?.preserveFormatting) {
+            rPr = this.extractFirstVisibleRunProperties();
+        }
+        const delRunChildren = [];
+        if (rPr)
+            delRunChildren.push(rPr);
+        delRunChildren.push({
+            name: 'w:delText',
+            attributes: { 'xml:space': 'preserve' },
+            children: [currentText],
+        });
+        const delElement = {
+            name: 'w:del',
+            attributes: { 'w:id': String(delId), 'w:author': author, 'w:date': date },
+            children: [{ name: 'w:r', children: delRunChildren }],
+        };
+        const insRunChildren = [];
+        if (rPr)
+            insRunChildren.push(rPr);
+        insRunChildren.push({
+            name: 'w:t',
+            attributes: { 'xml:space': 'preserve' },
+            children: [newText],
+        });
+        const insElement = {
+            name: 'w:ins',
+            attributes: { 'w:id': String(insId), 'w:author': author, 'w:date': date },
+            children: [{ name: 'w:r', children: insRunChildren }],
+        };
+        this.resultContent = [delElement, insElement];
+        this.result = newText;
+        this.resultRevisions = [];
+        return this;
+    }
+    extractFirstVisibleRunProperties() {
+        for (const element of this.resultContent) {
+            if (element.name === 'w:r') {
+                const rPr = (element.children || []).find((c) => typeof c !== 'string' && c.name === 'w:rPr');
+                if (rPr)
+                    return rPr;
+            }
+            else if (element.name === 'w:ins') {
+                for (const child of element.children || []) {
+                    if (typeof child !== 'string' && child.name === 'w:r') {
+                        const rPr = (child.children || []).find((c) => typeof c !== 'string' && c.name === 'w:rPr');
+                        if (rPr)
+                            return rPr;
+                    }
+                }
+            }
+        }
+        if (this.resultFormatting) {
+            return this.createRunProperties(this.resultFormatting);
+        }
+        return null;
+    }
+    setMultiParagraph(multiParagraph) {
+        this.multiParagraph = multiParagraph;
+        return this;
+    }
+    isMultiParagraph() {
+        return this.multiParagraph;
+    }
+    setResultRevisions(revisions) {
+        this.resultRevisions = revisions;
+        return this;
+    }
+    addResultRevision(revision) {
+        this.resultRevisions.push(revision);
+        return this;
+    }
+    getResultRevisions() {
+        return [...this.resultRevisions];
+    }
+    hasResultRevisions() {
+        return this.resultRevisions.length > 0;
+    }
+    toXML() {
+        const runs = [];
+        const beginFldChar = this._formFieldData
+            ? this.buildFldCharWithFfData()
+            : {
+                name: 'w:fldChar',
+                attributes: { 'w:fldCharType': 'begin' },
+                selfClosing: true,
+            };
+        runs.push({
+            name: 'w:r',
+            children: [beginFldChar],
+        });
+        const instrChildren = [];
+        if (this.instructionFormatting) {
+            instrChildren.push(this.createRunProperties(this.instructionFormatting));
+        }
+        instrChildren.push({
+            name: 'w:instrText',
+            attributes: { 'xml:space': 'preserve' },
+            children: [this.instruction],
+        });
+        runs.push({
+            name: 'w:r',
+            children: instrChildren,
+        });
+        for (const nestedField of this.nestedFields) {
+            runs.push(...nestedField.toXML());
+        }
+        runs.push({
+            name: 'w:r',
+            children: [
+                {
+                    name: 'w:fldChar',
+                    attributes: { 'w:fldCharType': 'separate' },
+                    selfClosing: true,
+                },
+            ],
+        });
+        if (this.resultContent.length > 0) {
+            runs.push(...this.resultContent);
+        }
+        else if (this.result) {
+            const resultChildren = [];
+            if (this.resultFormatting) {
+                resultChildren.push(this.createRunProperties(this.resultFormatting));
+            }
+            resultChildren.push({
+                name: 'w:t',
+                attributes: { 'xml:space': 'preserve' },
+                children: [this.result],
+            });
+            runs.push({
+                name: 'w:r',
+                children: resultChildren,
+            });
+        }
+        if (this.resultContent.length === 0) {
+            for (const revision of this.resultRevisions) {
+                const revisionXml = revision.toXML();
+                if (revisionXml) {
+                    runs.push(revisionXml);
+                }
+            }
+        }
+        runs.push({
+            name: 'w:r',
+            children: [
+                {
+                    name: 'w:fldChar',
+                    attributes: { 'w:fldCharType': 'end' },
+                    selfClosing: true,
+                },
+            ],
+        });
+        return runs;
+    }
+    createRunProperties(formatting) {
+        const children = [];
+        if (formatting.bold) {
+            children.push({ name: 'w:b', selfClosing: true });
+        }
+        if (formatting.italic) {
+            children.push({ name: 'w:i', selfClosing: true });
+        }
+        if (formatting.underline) {
+            const val = typeof formatting.underline === 'string' ? formatting.underline : 'single';
+            children.push({
+                name: 'w:u',
+                attributes: { 'w:val': val },
+                selfClosing: true,
+            });
+        }
+        if (formatting.strike) {
+            children.push({ name: 'w:strike', selfClosing: true });
+        }
+        if (formatting.font) {
+            children.push({
+                name: 'w:rFonts',
+                attributes: {
+                    'w:ascii': formatting.font,
+                    'w:hAnsi': formatting.font,
+                    'w:cs': formatting.font,
+                },
+                selfClosing: true,
+            });
+        }
+        if (formatting.size) {
+            const sizeValue = pointsToHalfPoints(formatting.size).toString();
+            children.push({
+                name: 'w:sz',
+                attributes: { 'w:val': sizeValue },
+                selfClosing: true,
+            });
+            children.push({
+                name: 'w:szCs',
+                attributes: { 'w:val': sizeValue },
+                selfClosing: true,
+            });
+        }
+        if (formatting.color) {
+            const color = formatting.color.replace('#', '');
+            children.push({
+                name: 'w:color',
+                attributes: { 'w:val': color },
+                selfClosing: true,
+            });
+        }
+        if (formatting.highlight) {
+            children.push({
+                name: 'w:highlight',
+                attributes: { 'w:val': formatting.highlight },
+                selfClosing: true,
+            });
+        }
+        return { name: 'w:rPr', children };
+    }
+    buildFldCharWithFfData() {
+        const ffd = this._formFieldData;
+        const ffDataChildren = [];
+        if (ffd.name) {
+            ffDataChildren.push({ name: 'w:name', attributes: { 'w:val': ffd.name }, selfClosing: true });
+        }
+        if (ffd.enabled !== undefined) {
+            if (ffd.enabled) {
+                ffDataChildren.push({ name: 'w:enabled', selfClosing: true });
+            }
+            else {
+                ffDataChildren.push({ name: 'w:enabled', attributes: { 'w:val': '0' }, selfClosing: true });
+            }
+        }
+        if (ffd.calcOnExit !== undefined) {
+            ffDataChildren.push({
+                name: 'w:calcOnExit',
+                attributes: { 'w:val': ffd.calcOnExit ? '1' : '0' },
+                selfClosing: true,
+            });
+        }
+        if (ffd.helpText) {
+            ffDataChildren.push({
+                name: 'w:helpText',
+                attributes: { 'w:type': 'text', 'w:val': ffd.helpText },
+                selfClosing: true,
+            });
+        }
+        if (ffd.statusText) {
+            ffDataChildren.push({
+                name: 'w:statusText',
+                attributes: { 'w:type': 'text', 'w:val': ffd.statusText },
+                selfClosing: true,
+            });
+        }
+        if (ffd.entryMacro) {
+            ffDataChildren.push({
+                name: 'w:entryMacro',
+                attributes: { 'w:val': ffd.entryMacro },
+                selfClosing: true,
+            });
+        }
+        if (ffd.exitMacro) {
+            ffDataChildren.push({
+                name: 'w:exitMacro',
+                attributes: { 'w:val': ffd.exitMacro },
+                selfClosing: true,
+            });
+        }
+        if (ffd.fieldType) {
+            switch (ffd.fieldType.type) {
+                case 'textInput': {
+                    const tiChildren = [];
+                    if (ffd.fieldType.inputType)
+                        tiChildren.push({
+                            name: 'w:type',
+                            attributes: { 'w:val': ffd.fieldType.inputType },
+                            selfClosing: true,
+                        });
+                    if (ffd.fieldType.defaultValue)
+                        tiChildren.push({
+                            name: 'w:default',
+                            attributes: { 'w:val': ffd.fieldType.defaultValue },
+                            selfClosing: true,
+                        });
+                    if (ffd.fieldType.maxLength !== undefined)
+                        tiChildren.push({
+                            name: 'w:maxLength',
+                            attributes: { 'w:val': String(ffd.fieldType.maxLength) },
+                            selfClosing: true,
+                        });
+                    if (ffd.fieldType.format)
+                        tiChildren.push({
+                            name: 'w:format',
+                            attributes: { 'w:val': ffd.fieldType.format },
+                            selfClosing: true,
+                        });
+                    ffDataChildren.push({ name: 'w:textInput', children: tiChildren });
+                    break;
+                }
+                case 'checkBox': {
+                    const cbChildren = [];
+                    if (ffd.fieldType.size === 'auto') {
+                        cbChildren.push({ name: 'w:sizeAuto', selfClosing: true });
+                    }
+                    else if (ffd.fieldType.size !== undefined) {
+                        cbChildren.push({
+                            name: 'w:size',
+                            attributes: { 'w:val': String(ffd.fieldType.size) },
+                            selfClosing: true,
+                        });
+                    }
+                    if (ffd.fieldType.defaultChecked !== undefined)
+                        cbChildren.push({
+                            name: 'w:default',
+                            attributes: { 'w:val': ffd.fieldType.defaultChecked ? '1' : '0' },
+                            selfClosing: true,
+                        });
+                    if (ffd.fieldType.checked !== undefined)
+                        cbChildren.push({
+                            name: 'w:checked',
+                            attributes: { 'w:val': ffd.fieldType.checked ? '1' : '0' },
+                            selfClosing: true,
+                        });
+                    ffDataChildren.push({ name: 'w:checkBox', children: cbChildren });
+                    break;
+                }
+                case 'dropDownList': {
+                    const ddChildren = [];
+                    if (ffd.fieldType.result !== undefined)
+                        ddChildren.push({
+                            name: 'w:result',
+                            attributes: { 'w:val': String(ffd.fieldType.result) },
+                            selfClosing: true,
+                        });
+                    if (ffd.fieldType.defaultResult !== undefined)
+                        ddChildren.push({
+                            name: 'w:default',
+                            attributes: { 'w:val': String(ffd.fieldType.defaultResult) },
+                            selfClosing: true,
+                        });
+                    if (ffd.fieldType.listEntries) {
+                        for (const entry of ffd.fieldType.listEntries) {
+                            ddChildren.push({
+                                name: 'w:listEntry',
+                                attributes: { 'w:val': entry },
+                                selfClosing: true,
+                            });
+                        }
+                    }
+                    ffDataChildren.push({ name: 'w:ddList', children: ddChildren });
+                    break;
+                }
+            }
+        }
+        return {
+            name: 'w:fldChar',
+            attributes: { 'w:fldCharType': 'begin' },
+            children: [{ name: 'w:ffData', children: ffDataChildren }],
+        };
+    }
+}
+export function createTOCField(options = {}) {
+    let instruction = ' TOC';
+    if (options.levels !== undefined) {
+        instruction += ` \\o "${options.levels}"`;
+    }
+    else {
+        instruction += ' \\o "1-3"';
+    }
+    if (options.hyperlinks !== false) {
+        instruction += ' \\h';
+    }
+    if (options.hideInWebLayout !== false) {
+        instruction += ' \\z';
+    }
+    if (options.useOutlineLevels !== false) {
+        instruction += ' \\u';
+    }
+    if (options.omitPageNumbers) {
+        instruction += ' \\n';
+    }
+    if (options.customStyles) {
+        instruction += ` \\t "${options.customStyles}"`;
+    }
+    instruction += ' ';
+    return new ComplexField({
+        instruction,
+        result: 'Table of Contents',
+    });
+}
+//# sourceMappingURL=Field.js.map