docxmlater 9.6.0 → 9.6.2

package/dist/core/Document.js

@@ -56,7 +56,9 @@ const TableOfContentsElement_1 = require("../elements/TableOfContentsElement");
 const NumberingManager_1 = require("../formatting/NumberingManager");
 const Style_1 = require("../formatting/Style");
 const StylesManager_1 = require("../formatting/StylesManager");
-const ListNormalizer_1 = require("./ListNormalizer");
+const compatibility_types_1 = require("../types/compatibility-types");
+const CompatibilityUpgrader_1 = require("../utils/CompatibilityUpgrader");
+const legacyCompatFlags_1 = require("../constants/legacyCompatFlags");
 const logger_1 = require("../utils/logger");
 const units_1 = require("../utils/units");
 function getLogger() {
@@ -147,6 +149,9 @@ class Document {
     _originalContentTypes;
     _originalStylesXml;
     _originalNumberingXml;
+    _originalSettingsXml;
+    _settingsModified = false;
+    _compatInfo;
     rsidRoot;
     rsids = new Set();
     documentProtection;
@@ -217,6 +222,11 @@ class Document {
         if (numberingXml) {
             doc._originalNumberingXml = numberingXml;
         }
+        const settingsXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.SETTINGS);
+        if (settingsXml) {
+            doc._originalSettingsXml = settingsXml;
+            doc.parseSettingsFromXml(settingsXml);
+        }
         await doc.parseDocument();
         if (useInMemoryAccept) {
             logger.info('Accepting revisions using in-memory transformation');
@@ -263,6 +273,11 @@ class Document {
         if (numberingXml) {
             doc._originalNumberingXml = numberingXml;
         }
+        const settingsXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.SETTINGS);
+        if (settingsXml) {
+            doc._originalSettingsXml = settingsXml;
+            doc.parseSettingsFromXml(settingsXml);
+        }
         await doc.parseDocument();
         if (useInMemoryAccept) {
             logger.info('Accepting revisions using in-memory transformation');
@@ -272,6 +287,140 @@ class Document {
         logger.info('Document loaded from buffer', { paragraphs: doc.getParagraphCount() });
         return doc;
     }
+    parseSettingsFromXml(settingsXml) {
+        const trackRevisionsMatch = settingsXml.match(/<w:trackRevisions\b([^>]*)\/?>/);
+        if (trackRevisionsMatch) {
+            const attrs = trackRevisionsMatch[1] ?? '';
+            const valMatch = attrs.match(/w:val\s*=\s*"([^"]*)"/);
+            if (valMatch && valMatch[1] !== undefined) {
+                const val = valMatch[1].toLowerCase();
+                this.trackChangesEnabled = val !== 'false' && val !== '0' && val !== 'off';
+            }
+            else {
+                this.trackChangesEnabled = true;
+            }
+        }
+        const hasDoNotTrackFormatting = /<w:doNotTrackFormatting\b[^>]*\/?>/.test(settingsXml);
+        if (hasDoNotTrackFormatting) {
+            this.trackFormatting = false;
+        }
+        const hasTrackFormatting = /<w:trackFormatting\b[^>]*\/?>/.test(settingsXml);
+        if (hasTrackFormatting) {
+            this.trackFormatting = true;
+        }
+        const revisionViewMatch = settingsXml.match(/<w:revisionView\b([^>]*)\/?>/);
+        if (revisionViewMatch) {
+            const attrs = revisionViewMatch[1] || '';
+            const insDelMatch = attrs.match(/w:insDel\s*=\s*"([^"]*)"/);
+            const formattingMatch = attrs.match(/w:formatting\s*=\s*"([^"]*)"/);
+            const inkMatch = attrs.match(/w:inkAnnotations\s*=\s*"([^"]*)"/);
+            if (insDelMatch?.[1] !== undefined) {
+                this.revisionViewSettings.showInsertionsAndDeletions = insDelMatch[1] !== '0';
+            }
+            if (formattingMatch?.[1] !== undefined) {
+                this.revisionViewSettings.showFormatting = formattingMatch[1] !== '0';
+            }
+            if (inkMatch?.[1] !== undefined) {
+                this.revisionViewSettings.showInkAnnotations = inkMatch[1] !== '0';
+            }
+        }
+        const protMatch = settingsXml.match(/<w:documentProtection\b([^>]*)\/?>/);
+        if (protMatch) {
+            const attrs = protMatch[1] || '';
+            const editMatch = attrs.match(/w:edit\s*=\s*"([^"]*)"/);
+            const enforcementMatch = attrs.match(/w:enforcement\s*=\s*"([^"]*)"/);
+            if (editMatch?.[1]) {
+                const edit = editMatch[1];
+                const enforcement = enforcementMatch?.[1] ? enforcementMatch[1] !== '0' : true;
+                this.documentProtection = { edit, enforcement };
+                const cryptProviderMatch = attrs.match(/w:cryptProviderType\s*=\s*"([^"]*)"/);
+                const cryptAlgClassMatch = attrs.match(/w:cryptAlgorithmClass\s*=\s*"([^"]*)"/);
+                const cryptAlgTypeMatch = attrs.match(/w:cryptAlgorithmType\s*=\s*"([^"]*)"/);
+                const cryptAlgSidMatch = attrs.match(/w:cryptAlgorithmSid\s*=\s*"([^"]*)"/);
+                const cryptSpinMatch = attrs.match(/w:cryptSpinCount\s*=\s*"([^"]*)"/);
+                const hashMatch = attrs.match(/w:hash\s*=\s*"([^"]*)"/);
+                const saltMatch = attrs.match(/w:salt\s*=\s*"([^"]*)"/);
+                if (cryptProviderMatch?.[1])
+                    this.documentProtection.cryptProviderType = cryptProviderMatch[1];
+                if (cryptAlgClassMatch?.[1])
+                    this.documentProtection.cryptAlgorithmClass = cryptAlgClassMatch[1];
+                if (cryptAlgTypeMatch?.[1])
+                    this.documentProtection.cryptAlgorithmType = cryptAlgTypeMatch[1];
+                if (cryptAlgSidMatch?.[1])
+                    this.documentProtection.cryptAlgorithmSid = parseInt(cryptAlgSidMatch[1], 10);
+                if (cryptSpinMatch?.[1])
+                    this.documentProtection.cryptSpinCount = parseInt(cryptSpinMatch[1], 10);
+                if (hashMatch?.[1])
+                    this.documentProtection.hash = hashMatch[1];
+                if (saltMatch?.[1])
+                    this.documentProtection.salt = saltMatch[1];
+            }
+        }
+        const rsidsBlockMatch = settingsXml.match(/<w:rsids>([\s\S]*?)<\/w:rsids>/);
+        if (rsidsBlockMatch?.[1]) {
+            const rsidsBlock = rsidsBlockMatch[1];
+            const rsidRootMatch = rsidsBlock.match(/<w:rsidRoot\s+w:val\s*=\s*"([^"]*)"\s*\/?>/);
+            if (rsidRootMatch?.[1]) {
+                this.rsidRoot = rsidRootMatch[1].toUpperCase();
+            }
+            const rsidRegex = /<w:rsid\s+w:val\s*=\s*"([^"]*)"\s*\/?>/g;
+            let rsidMatch;
+            while ((rsidMatch = rsidRegex.exec(rsidsBlock)) !== null) {
+                if (rsidMatch[1])
+                    this.rsids.add(rsidMatch[1].toUpperCase());
+            }
+            if (this.rsidRoot) {
+                this.rsids.add(this.rsidRoot);
+            }
+        }
+        this._compatInfo = this.parseCompatBlock(settingsXml);
+    }
+    parseCompatBlock(settingsXml) {
+        const compatSettings = [];
+        const legacyFlags = [];
+        let mode = compatibility_types_1.CompatibilityMode.Word2007;
+        const compatBlockMatch = settingsXml.match(/<w:compat>([\s\S]*?)<\/w:compat>/);
+        if (compatBlockMatch?.[1]) {
+            const compatBlock = compatBlockMatch[1];
+            const settingRegex = /<w:compatSetting\s+([^>]*)\/?\s*>/g;
+            let settingMatch;
+            while ((settingMatch = settingRegex.exec(compatBlock)) !== null) {
+                const attrs = settingMatch[1] ?? '';
+                const nameMatch = attrs.match(/w:name\s*=\s*"([^"]*)"/);
+                const uriMatch = attrs.match(/w:uri\s*=\s*"([^"]*)"/);
+                const valMatch = attrs.match(/w:val\s*=\s*"([^"]*)"/);
+                if (nameMatch?.[1] && uriMatch?.[1] && valMatch?.[1]) {
+                    const setting = {
+                        name: nameMatch[1],
+                        uri: uriMatch[1],
+                        val: valMatch[1],
+                    };
+                    compatSettings.push(setting);
+                    if (setting.name === 'compatibilityMode' &&
+                        setting.uri === 'http://schemas.microsoft.com/office/word') {
+                        const modeVal = parseInt(setting.val, 10);
+                        if (!isNaN(modeVal)) {
+                            mode = modeVal;
+                        }
+                    }
+                }
+            }
+            const legacyFlagRegex = /<w:(\w+)(?:\s[^>]*)?\/?>/g;
+            let flagMatch;
+            while ((flagMatch = legacyFlagRegex.exec(compatBlock)) !== null) {
+                const tagName = flagMatch[1];
+                if (!tagName || tagName === 'compatSetting')
+                    continue;
+                legacyFlags.push(tagName);
+            }
+        }
+        return {
+            mode,
+            isLegacyMode: mode < compatibility_types_1.CompatibilityMode.Word2013Plus,
+            compatSettings,
+            legacyFlags,
+        };
+    }
     async parseDocument() {
         const result = await this.parser.parseDocument(this.zipHandler, this.relationshipManager, this.imageManager, this.bookmarkManager);
         this.bodyElements = result.bodyElements;
@@ -377,7 +526,7 @@ class Document {
         this.zipHandler.addFile(types_1.DOCX_PATHS.STYLES, this.stylesManager.generateStylesXml());
         this.zipHandler.addFile(types_1.DOCX_PATHS.NUMBERING, this.numberingManager.generateNumberingXml());
         this.zipHandler.addFile("word/fontTable.xml", this.generator.generateFontTable());
-        this.zipHandler.addFile("word/settings.xml", this.generator.generateSettings({
+        this.zipHandler.addFile(types_1.DOCX_PATHS.SETTINGS, this.generator.generateSettings({
             trackChangesEnabled: this.trackChangesEnabled,
             trackFormatting: this.trackFormatting,
             revisionView: this.revisionViewSettings,
@@ -385,6 +534,18 @@ class Document {
             rsids: this.getRsids(),
             documentProtection: this.documentProtection,
         }));
+        this._compatInfo = {
+            mode: compatibility_types_1.CompatibilityMode.Word2013Plus,
+            isLegacyMode: false,
+            compatSettings: [
+                { name: 'compatibilityMode', uri: 'http://schemas.microsoft.com/office/word', val: '15' },
+                { name: 'overrideTableStyleFontSizeAndJustification', uri: 'http://schemas.microsoft.com/office/word', val: '1' },
+                { name: 'enableOpenTypeFeatures', uri: 'http://schemas.microsoft.com/office/word', val: '1' },
+                { name: 'doNotFlipMirrorIndents', uri: 'http://schemas.microsoft.com/office/word', val: '1' },
+                { name: 'differentiateMultirowTableHeaders', uri: 'http://schemas.microsoft.com/office/word', val: '1' },
+            ],
+            legacyFlags: [],
+        };
         this.zipHandler.addFile("word/theme/theme1.xml", this.generator.generateTheme());
         this.zipHandler.addFile(types_1.DOCX_PATHS.CORE_PROPS, this.generator.generateCoreProps(this.properties));
         this.zipHandler.addFile(types_1.DOCX_PATHS.APP_PROPS, this.generator.generateAppProps(this.properties));
@@ -504,11 +665,6 @@ class Document {
         }
         return result;
     }
-    normalizeTableLists(options) {
-        const normalizer = new ListNormalizer_1.ListNormalizer(this.numberingManager);
-        const tables = this.getAllTables();
-        return normalizer.normalizeAllTables(tables, options);
-    }
     getTableOfContentsElements() {
         return this.bodyElements.filter((el) => el instanceof TableOfContentsElement_1.TableOfContentsElement);
     }
@@ -644,6 +800,7 @@ class Document {
             }
             this.updateStylesXml();
             this.updateNumberingXml();
+            this.updateSettingsXml();
             this.updateCoreProps();
             this.updateAppProps();
             this.saveImages();
@@ -717,6 +874,7 @@ class Document {
             }
             this.updateStylesXml();
             this.updateNumberingXml();
+            this.updateSettingsXml();
             this.updateCoreProps();
             this.updateAppProps();
             this.saveImages();
@@ -724,6 +882,7 @@ class Document {
             this.saveFooters();
             this.saveComments();
             this.updatePeopleXml();
+            this.saveCustomProperties();
             this.updateRelationships();
             this.updateContentTypesWithImagesHeadersFootersAndComments();
             if (this.autoPopulateTOCs) {
@@ -812,6 +971,127 @@ class Document {
             this.zipHandler.updateFile(types_1.DOCX_PATHS.NUMBERING, xml);
         }
     }
+    updateSettingsXml() {
+        const xml = this.mergeSettingsWithOriginal();
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.SETTINGS, xml);
+    }
+    mergeSettingsWithOriginal() {
+        if (!this._originalSettingsXml) {
+            return this.generator.generateSettings({
+                trackChangesEnabled: this.trackChangesEnabled,
+                trackFormatting: this.trackFormatting,
+                revisionView: this.revisionViewSettings,
+                rsidRoot: this.rsidRoot,
+                rsids: this.getRsids(),
+                documentProtection: this.documentProtection,
+            });
+        }
+        if (!this._settingsModified) {
+            return this._originalSettingsXml;
+        }
+        let xml = this._originalSettingsXml;
+        xml = this.mergeTrackChangesIntoSettings(xml);
+        xml = this.mergeProtectionIntoSettings(xml);
+        xml = this.mergeRsidsIntoSettings(xml);
+        return xml;
+    }
+    mergeTrackChangesIntoSettings(xml) {
+        xml = xml.replace(/<w:trackRevisions\b[^>]*\/>/g, '');
+        xml = xml.replace(/<w:trackRevisions\b[^>]*>[\s\S]*?<\/w:trackRevisions>/g, '');
+        xml = xml.replace(/<w:doNotTrackFormatting\b[^>]*\/>/g, '');
+        xml = xml.replace(/<w:doNotTrackFormatting\b[^>]*>[\s\S]*?<\/w:doNotTrackFormatting>/g, '');
+        xml = xml.replace(/<w:trackFormatting\b[^>]*\/>/g, '');
+        xml = xml.replace(/<w:trackFormatting\b[^>]*>[\s\S]*?<\/w:trackFormatting>/g, '');
+        xml = xml.replace(/<w:revisionView\b[^>]*\/>/g, '');
+        xml = xml.replace(/<w:revisionView\b[^>]*>[\s\S]*?<\/w:revisionView>/g, '');
+        let trackBlock = '';
+        const view = this.revisionViewSettings;
+        if (!view.showInsertionsAndDeletions || !view.showFormatting || !view.showInkAnnotations) {
+            trackBlock += `\n  <w:revisionView w:insDel="${view.showInsertionsAndDeletions ? '1' : '0'}" w:formatting="${view.showFormatting ? '1' : '0'}" w:inkAnnotations="${view.showInkAnnotations ? '1' : '0'}"/>`;
+        }
+        if (this.trackChangesEnabled) {
+            trackBlock += '\n  <w:trackRevisions/>';
+        }
+        if (!this.trackFormatting) {
+            trackBlock += '\n  <w:doNotTrackFormatting/>';
+        }
+        if (trackBlock) {
+            if (/<w:documentProtection\b/.test(xml)) {
+                xml = xml.replace(/<w:documentProtection\b/, trackBlock + '\n  <w:documentProtection');
+            }
+            else if (/<w:autoFormatOverride\b/.test(xml)) {
+                xml = xml.replace(/<w:autoFormatOverride\b/, trackBlock + '\n  <w:autoFormatOverride');
+            }
+            else if (/<w:defaultTabStop\b/.test(xml)) {
+                xml = xml.replace(/<w:defaultTabStop\b/, trackBlock + '\n  <w:defaultTabStop');
+            }
+            else {
+                xml = xml.replace(/<\/w:settings>/, trackBlock + '\n</w:settings>');
+            }
+        }
+        return xml;
+    }
+    mergeProtectionIntoSettings(xml) {
+        xml = xml.replace(/<w:documentProtection\b[^>]*\/>/g, '');
+        xml = xml.replace(/<w:documentProtection\b[^>]*>[\s\S]*?<\/w:documentProtection>/g, '');
+        if (!this.documentProtection) {
+            return xml;
+        }
+        const prot = this.documentProtection;
+        let protXml = `\n  <w:documentProtection w:edit="${prot.edit}" w:enforcement="${prot.enforcement ? '1' : '0'}"`;
+        if (prot.cryptProviderType)
+            protXml += ` w:cryptProviderType="${prot.cryptProviderType}"`;
+        if (prot.cryptAlgorithmClass)
+            protXml += ` w:cryptAlgorithmClass="${prot.cryptAlgorithmClass}"`;
+        if (prot.cryptAlgorithmType)
+            protXml += ` w:cryptAlgorithmType="${prot.cryptAlgorithmType}"`;
+        if (prot.cryptAlgorithmSid)
+            protXml += ` w:cryptAlgorithmSid="${prot.cryptAlgorithmSid}"`;
+        if (prot.cryptSpinCount)
+            protXml += ` w:cryptSpinCount="${prot.cryptSpinCount}"`;
+        if (prot.hash)
+            protXml += ` w:hash="${prot.hash}"`;
+        if (prot.salt)
+            protXml += ` w:salt="${prot.salt}"`;
+        protXml += '/>';
+        if (/<w:autoFormatOverride\b/.test(xml)) {
+            xml = xml.replace(/<w:autoFormatOverride\b/, protXml + '\n  <w:autoFormatOverride');
+        }
+        else if (/<w:defaultTabStop\b/.test(xml)) {
+            xml = xml.replace(/<w:defaultTabStop\b/, protXml + '\n  <w:defaultTabStop');
+        }
+        else {
+            xml = xml.replace(/<\/w:settings>/, protXml + '\n</w:settings>');
+        }
+        return xml;
+    }
+    mergeRsidsIntoSettings(xml) {
+        xml = xml.replace(/<w:rsids>[\s\S]*?<\/w:rsids>/g, '');
+        if (this.rsids.size === 0) {
+            return xml;
+        }
+        let rsidsXml = '\n  <w:rsids>';
+        if (this.rsidRoot) {
+            rsidsXml += `\n    <w:rsidRoot w:val="${this.rsidRoot}"/>`;
+        }
+        for (const rsid of this.rsids) {
+            rsidsXml += `\n    <w:rsid w:val="${rsid}"/>`;
+        }
+        rsidsXml += '\n  </w:rsids>';
+        if (/<\/w:compat>/.test(xml)) {
+            xml = xml.replace(/<\/w:compat>/, '</w:compat>' + rsidsXml);
+        }
+        else if (/<m:mathPr\b/.test(xml)) {
+            xml = xml.replace(/<m:mathPr\b/, rsidsXml + '\n  <m:mathPr');
+        }
+        else if (/<w:themeFontLang\b/.test(xml)) {
+            xml = xml.replace(/<w:themeFontLang\b/, rsidsXml + '\n  <w:themeFontLang');
+        }
+        else {
+            xml = xml.replace(/<\/w:settings>/, rsidsXml + '\n</w:settings>');
+        }
+        return xml;
+    }
     getStylesManager() {
         return this.stylesManager;
     }
@@ -3901,6 +4181,7 @@ class Document {
             this.clearAllParagraphPropertyChanges();
         }
         this.trackChangesEnabled = true;
+        this._settingsModified = true;
         if (options) {
             if (options.trackFormatting !== undefined) {
                 this.trackFormatting = options.trackFormatting;
@@ -3926,6 +4207,7 @@ class Document {
     }
     disableTrackChanges() {
         this.trackChangesEnabled = false;
+        this._settingsModified = true;
         this.trackingContext.disable();
         return this;
     }
@@ -3992,6 +4274,7 @@ class Document {
         }
         this.rsidRoot = rsidRoot.toUpperCase();
         this.rsids.add(this.rsidRoot);
+        this._settingsModified = true;
         return this;
     }
     addRsid(rsid) {
@@ -3999,6 +4282,7 @@ class Document {
             throw new Error("RSID must be an 8-character hexadecimal value");
         }
         this.rsids.add(rsid.toUpperCase());
+        this._settingsModified = true;
         return this;
     }
     generateRsid() {
@@ -4007,6 +4291,7 @@ class Document {
             .toUpperCase()
             .padStart(8, "0");
         this.rsids.add(rsid);
+        this._settingsModified = true;
         return rsid;
     }
     getRsidRoot() {
@@ -4025,6 +4310,7 @@ class Document {
             cryptAlgorithmSid: protection.cryptAlgorithmSid,
             cryptSpinCount: protection.cryptSpinCount,
         };
+        this._settingsModified = true;
         if (protection.password) {
             const crypto = require("crypto");
             const salt = crypto.randomBytes(16).toString("base64");
@@ -4038,6 +4324,7 @@ class Document {
     }
     unprotectDocument() {
         this.documentProtection = undefined;
+        this._settingsModified = true;
         return this;
     }
     isProtected() {
@@ -4046,6 +4333,65 @@ class Document {
     getProtection() {
         return this.documentProtection;
     }
+    getCompatibilityMode() {
+        return this._compatInfo?.mode ?? compatibility_types_1.CompatibilityMode.Word2007;
+    }
+    isCompatibilityMode() {
+        return this._compatInfo?.isLegacyMode ?? true;
+    }
+    getCompatibilityInfo() {
+        return this._compatInfo ?? {
+            mode: compatibility_types_1.CompatibilityMode.Word2007,
+            isLegacyMode: true,
+            compatSettings: [],
+            legacyFlags: [],
+        };
+    }
+    upgradeToModernFormat() {
+        const currentMode = this.getCompatibilityMode();
+        const currentInfo = this.getCompatibilityInfo();
+        if (currentMode === compatibility_types_1.CompatibilityMode.Word2013Plus && currentInfo.legacyFlags.length === 0) {
+            return {
+                previousMode: currentMode,
+                newMode: 15,
+                removedFlags: [],
+                addedSettings: [],
+                namespacesExpanded: false,
+                changed: false,
+            };
+        }
+        if (this._originalSettingsXml) {
+            const result = CompatibilityUpgrader_1.CompatibilityUpgrader.upgradeCompatBlock(this._originalSettingsXml, currentMode);
+            this._originalSettingsXml = result.xml;
+            this._settingsModified = true;
+            const nsResult = CompatibilityUpgrader_1.CompatibilityUpgrader.ensureModernNamespaces(this.namespaces);
+            this.namespaces = nsResult.namespaces;
+            result.report.namespacesExpanded = nsResult.expanded;
+            this._compatInfo = {
+                mode: compatibility_types_1.CompatibilityMode.Word2013Plus,
+                isLegacyMode: false,
+                compatSettings: [...legacyCompatFlags_1.MODERN_COMPAT_SETTINGS],
+                legacyFlags: [],
+            };
+            return result.report;
+        }
+        this._compatInfo = {
+            mode: compatibility_types_1.CompatibilityMode.Word2013Plus,
+            isLegacyMode: false,
+            compatSettings: [...legacyCompatFlags_1.MODERN_COMPAT_SETTINGS],
+            legacyFlags: [],
+        };
+        const nsResult = CompatibilityUpgrader_1.CompatibilityUpgrader.ensureModernNamespaces(this.namespaces);
+        this.namespaces = nsResult.namespaces;
+        return {
+            previousMode: currentMode,
+            newMode: 15,
+            removedFlags: [],
+            addedSettings: legacyCompatFlags_1.MODERN_COMPAT_SETTINGS.map(s => s.name),
+            namespacesExpanded: nsResult.expanded,
+            changed: currentMode !== compatibility_types_1.CompatibilityMode.Word2013Plus,
+        };
+    }
     createRunPropertiesChange(author, content, previousProperties, date) {
         const revision = Revision_1.Revision.createRunPropertiesChange(author, content, previousProperties, date);
         return this.revisionManager.register(revision);
@@ -4381,8 +4727,21 @@ class Document {
         this.trackingContext.disable();
         this._originalStylesXml = undefined;
         this._originalNumberingXml = undefined;
+        this._originalSettingsXml = undefined;
         this._originalContentTypes = undefined;
+        this._settingsModified = false;
+        this._compatInfo = undefined;
         this.saveStateSnapshot = undefined;
+        this.trackChangesEnabled = false;
+        this.trackFormatting = true;
+        this.revisionViewSettings = {
+            showInsertionsAndDeletions: true,
+            showFormatting: true,
+            showInkAnnotations: true,
+        };
+        this.rsidRoot = undefined;
+        this.rsids = new Set();
+        this.documentProtection = undefined;
         this.properties = {};
         this.section = Section_1.Section.create();
         this.namespaces = {};