devexpress-richedit 25.1.1-alpha → 25.1.3

package/dist/dx.richedit.js

@@ -1,6 +1,6 @@
 /**
 * DevExpress WebRichEdit (dx.richedit.js)
-* Version: 25.1.1
+* Version: 25.1.3
 * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs
 */
@@ -9486,6 +9486,219 @@ class ShadingInfo {
     }
 }
 
+// EXTERNAL MODULE: ./node_modules/@devexpress/utils/lib/utils/comparers.js
+var comparers = __webpack_require__(4170);
+;// CONCATENATED MODULE: ./src/common/model/history/base/history-item.ts
+
+class history_item_HistoryItem {
+    canBeMerged() {
+        return false;
+    }
+    constructor(modelManipulator) {
+        this.uniqueId = -1;
+        this.modelManipulator = modelManipulator;
+    }
+    changeModified() {
+        return true;
+    }
+}
+class CompositionHistoryItem extends history_item_HistoryItem {
+    canBeMerged() {
+        return true;
+    }
+    constructor() {
+        super(null);
+        this.historyItems = [];
+    }
+    changeModified() {
+        var item;
+        for (var i = 0; item = this.historyItems[i]; i++) {
+            if (item.changeModified())
+                return true;
+        }
+        return false;
+    }
+    redo() {
+        var item;
+        for (var i = 0; item = this.historyItems[i]; i++)
+            item.redo();
+    }
+    undo() {
+        var item;
+        for (var i = this.historyItems.length - 1; item = this.historyItems[i]; i--)
+            item.undo();
+    }
+    add(historyItem) {
+        if (historyItem == null)
+            throw new Error(lib_errors/* Errors */.D.ValueCannotBeNull);
+        this.historyItems.push(historyItem);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/common/model/history/base/interval-based-history-item.ts
+
+class interval_based_history_item_IntervalBasedHistoryItem extends history_item_HistoryItem {
+    get boundSubDocument() { return this.subDocInterval.subDocument; }
+    get interval() { return this.subDocInterval.interval; }
+    constructor(modelManipulator, subDocInterval) {
+        super(modelManipulator);
+        this.subDocInterval = subDocInterval;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/common/model/history/items/character-properties-history-items.ts
+
+
+class FontUseValueHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
+    constructor(modelManipulator, subDocInterval, newValue, keepCustomFormatting = false) {
+        super(modelManipulator, subDocInterval);
+        this.newValue = newValue;
+        this.keepCustomFormatting = keepCustomFormatting;
+    }
+    redo() {
+        this.oldState = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, this.newValue, this.keepCustomFormatting);
+    }
+    undo() {
+        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.oldState);
+    }
+}
+class CharacterPropertiesHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
+    constructor(modelManipulator, subDocInterval, newValue) {
+        super(modelManipulator, subDocInterval);
+        this.newValue = newValue;
+    }
+    redo() {
+        this.oldState = this.modelManipulator.characterProperties.setValue(this.boundSubDocument, this.interval, this.newValue);
+    }
+    undo() {
+        this.modelManipulator.characterProperties.restoreValue(this.boundSubDocument, this.oldState);
+    }
+}
+class CharacterPropertiesHistoryItemBase extends interval_based_history_item_IntervalBasedHistoryItem {
+    constructor(modelManipulator, subDocInterval, newValue, newUse) {
+        super(modelManipulator, subDocInterval);
+        this.newValue = newValue;
+        this.newUse = newUse;
+    }
+    redo() {
+        this.oldState = this.getPropertiesManipulator().setValue(this.boundSubDocument, this.interval, this.newValue, this.newUse);
+    }
+    undo() {
+        this.getPropertiesManipulator().restoreValue(this.boundSubDocument, this.oldState);
+    }
+    getPropertiesManipulator() {
+        throw new Error(lib_errors/* Errors */.D.NotImplemented);
+    }
+}
+class FontBoldHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontBold;
+    }
+}
+class FontCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontCaps;
+    }
+}
+class FontSmallCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontSmallCaps;
+    }
+}
+class FontUnderlineTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontUnderlineType;
+    }
+}
+class FontTextColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.textColor;
+    }
+}
+class FontShadingInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.shadingInfo;
+    }
+}
+class FontHiddenHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontHidden;
+    }
+}
+class FontItalicHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontItalic;
+    }
+}
+class FontNameHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontName;
+    }
+}
+class FontScriptHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.script;
+    }
+}
+class FontSizeHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontSize;
+    }
+}
+class FontStrikeoutTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontStrikeoutType;
+    }
+}
+class FontStrikeoutWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontStrikeoutWordsOnly;
+    }
+}
+class FontStrikeoutColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontStrikeoutColor;
+    }
+}
+class FontUnderlineColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontUnderlineColor;
+    }
+}
+class FontHighlightColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontHighlightColor;
+    }
+}
+class FontUnderlineWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontUnderlineWordsOnly;
+    }
+}
+class FontNoProofHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontNoProof;
+    }
+}
+class FontLangInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.langInfo;
+    }
+}
+class FontCompositeFontInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.compositeFontInfo;
+    }
+}
+class ResetCharacterPropertiesUseValuesHistoryItem extends (/* unused pure expression or super */ null && (IntervalBasedHistoryItem)) {
+    redo() {
+        this.state = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, 0);
+    }
+    undo() {
+        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.state);
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/common/model/character/enums.ts
 var CharacterPropertiesMask;
 (function (CharacterPropertiesMask) {
@@ -9643,6 +9856,498 @@ class LangInfo {
     }
 }
 
+;// CONCATENATED MODULE: ./src/common/model/character/character-property-descriptor.ts
+
+
+
+
+
+
+
+
+class CharacterPropertiesAllCapsDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.allCaps = newValue;
+    }
+    getProp(props) {
+        return props.allCaps;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseAllCaps;
+    }
+    getHistoryItemConstructor() {
+        return FontCapsHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.AllCaps;
+    }
+}
+class CharacterPropertiesSmallCapsDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.smallCaps = newValue;
+    }
+    getProp(props) {
+        return props.smallCaps;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseSmallCaps;
+    }
+    getHistoryItemConstructor() {
+        return FontSmallCapsHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.SmallCaps;
+    }
+}
+class CharacterPropertiesFontSizeDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = 11;
+    }
+    setProp(props, newValue) {
+        props.fontSize = newValue;
+    }
+    getProp(props) {
+        return props.fontSize;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseDoubleFontSize;
+    }
+    getHistoryItemConstructor() {
+        return FontSizeHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Size;
+    }
+}
+class CharacterPropertiesFontBoldDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.fontBold = newValue;
+    }
+    getProp(props) {
+        return props.fontBold;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontBold;
+    }
+    getHistoryItemConstructor() {
+        return FontBoldHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Bold;
+    }
+}
+class CharacterPropertiesFontItalicDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.fontItalic = newValue;
+    }
+    getProp(props) {
+        return props.fontItalic;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontItalic;
+    }
+    getHistoryItemConstructor() {
+        return FontItalicHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Italic;
+    }
+}
+class CharacterPropertiesFontInfoDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = undefined;
+    }
+    setProp(props, newValue) {
+        props.fontInfo = newValue;
+    }
+    getProp(props) {
+        return props.fontInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontName;
+    }
+    getHistoryItemConstructor() {
+        return FontNameHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.FontName;
+    }
+}
+class CharacterPropertiesScriptDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = CharacterFormattingScript.Normal;
+    }
+    setProp(props, newValue) {
+        props.script = newValue;
+    }
+    getProp(props) {
+        return props.script;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseScript;
+    }
+    getHistoryItemConstructor() {
+        return FontScriptHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Script;
+    }
+}
+class CharacterPropertiesStrikeoutTypeDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = StrikeoutType.None;
+    }
+    setProp(props, newValue) {
+        props.fontStrikeoutType = newValue;
+    }
+    getProp(props) {
+        return props.fontStrikeoutType;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontStrikeoutType;
+    }
+    getHistoryItemConstructor() {
+        return FontStrikeoutTypeHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.StrikeoutType;
+    }
+}
+class CharacterPropertiesUnderlineTypeDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = UnderlineType.None;
+    }
+    setProp(props, newValue) {
+        props.fontUnderlineType = newValue;
+    }
+    getProp(props) {
+        return props.fontUnderlineType;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontUnderlineType;
+    }
+    getHistoryItemConstructor() {
+        return FontUnderlineTypeHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.UnderlineType;
+    }
+}
+class CharacterPropertiesUnderlineWordsOnlyDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.underlineWordsOnly = newValue;
+    }
+    getProp(props) {
+        return props.underlineWordsOnly;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseUnderlineWordsOnly;
+    }
+    getHistoryItemConstructor() {
+        return FontUnderlineWordsOnlyHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.UnderlineWordsOnly;
+    }
+}
+class CharacterPropertiesStrikeoutWordsOnlyDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.strikeoutWordsOnly = newValue;
+    }
+    getProp(props) {
+        return props.strikeoutWordsOnly;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseStrikeoutWordsOnly;
+    }
+    getHistoryItemConstructor() {
+        return FontStrikeoutWordsOnlyHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.StrikeoutWordsOnly;
+    }
+}
+class CharacterPropertiesNoProofDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.noProof = newValue;
+    }
+    getProp(props) {
+        return props.noProof;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseNoProof;
+    }
+    getHistoryItemConstructor() {
+        return FontNoProofHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.NoProof;
+    }
+}
+class CharacterPropertiesHiddenDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.hidden = newValue;
+    }
+    getProp(props) {
+        return props.hidden;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseHidden;
+    }
+    getHistoryItemConstructor() {
+        return FontHiddenHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Hidden;
+    }
+}
+class CharacterPropertiesTextColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.autoColor;
+    }
+    setProp(props, newValue) {
+        props.textColor = newValue;
+    }
+    getProp(props) {
+        return props.textColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseForeColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontTextColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.TextColor;
+    }
+}
+class CharacterPropertiesShadingInfoColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = ShadingInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.shadingInfo = newValue;
+    }
+    getProp(props) {
+        return props.shadingInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseShadingInfoIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontShadingInfoHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.ShadingInfo;
+    }
+}
+class CharacterPropertiesStrikeoutColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.strikeoutColor = newValue;
+    }
+    getProp(props) {
+        return props.strikeoutColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseStrikeoutColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontStrikeoutColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.StrikeoutColor;
+    }
+}
+class CharacterPropertiesUnderlineColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.underlineColor = newValue;
+    }
+    getProp(props) {
+        return props.underlineColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseUnderlineColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontUnderlineColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.UnderlineColor;
+    }
+}
+class CharacterPropertiesHighlightColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.highlightColor = newValue;
+    }
+    getProp(props) {
+        return props.highlightColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseHighlightColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontHighlightColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.HighlightColor;
+    }
+}
+class CharacterPropertiesLangInfoDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = new LangInfo();
+    }
+    setProp(props, newValue) {
+        props.langInfo = newValue;
+    }
+    getProp(props) {
+        return props.langInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseLangInfo;
+    }
+    getHistoryItemConstructor() {
+        return FontLangInfoHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.LangInfo;
+    }
+}
+class CharacterPropertiesCompositeFontInfoDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = new CompositeFontInfo();
+    }
+    setProp(props, newValue) {
+        props.compositeFontInfo = newValue;
+    }
+    getProp(props) {
+        return props.compositeFontInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseCompositeFontInfo;
+    }
+    getHistoryItemConstructor() {
+        return FontCompositeFontInfoHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.CompositeFontInfo;
+    }
+}
+class character_property_descriptor_CharacterPropertyDescriptor {
+}
+character_property_descriptor_CharacterPropertyDescriptor.allCaps = new CharacterPropertiesAllCapsDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.size = new CharacterPropertiesFontSizeDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.bold = new CharacterPropertiesFontBoldDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.italic = new CharacterPropertiesFontItalicDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.fontInfo = new CharacterPropertiesFontInfoDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.script = new CharacterPropertiesScriptDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.strikeoutType = new CharacterPropertiesStrikeoutTypeDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.underlineType = new CharacterPropertiesUnderlineTypeDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly = new CharacterPropertiesUnderlineWordsOnlyDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly = new CharacterPropertiesStrikeoutWordsOnlyDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.noProof = new CharacterPropertiesNoProofDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.hidden = new CharacterPropertiesHiddenDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.langInfo = new CharacterPropertiesLangInfoDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo = new CharacterPropertiesCompositeFontInfoDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.textColor = new CharacterPropertiesTextColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.shadingInfo = new CharacterPropertiesShadingInfoColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.highlightColor = new CharacterPropertiesHighlightColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor = new CharacterPropertiesStrikeoutColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.underlineColor = new CharacterPropertiesUnderlineColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.smallCaps = new CharacterPropertiesSmallCapsDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.ALL_FIELDS = [
+    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
+    character_property_descriptor_CharacterPropertyDescriptor.size,
+    character_property_descriptor_CharacterPropertyDescriptor.bold,
+    character_property_descriptor_CharacterPropertyDescriptor.italic,
+    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.script,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineType,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.noProof,
+    character_property_descriptor_CharacterPropertyDescriptor.hidden,
+    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.textColor,
+    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.highlightColor,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
+    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
+];
+character_property_descriptor_CharacterPropertyDescriptor.whatNeedSetWhenCreateHyperlinkField = [
+    character_property_descriptor_CharacterPropertyDescriptor.size,
+    character_property_descriptor_CharacterPropertyDescriptor.bold,
+    character_property_descriptor_CharacterPropertyDescriptor.italic,
+    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.script,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
+    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.noProof,
+    character_property_descriptor_CharacterPropertyDescriptor.hidden,
+    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
+    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
+];
+
 ;// CONCATENATED MODULE: ./src/common/model/character/layout-character-properties-color-info.ts
 class LayoutCharacterPropertiesColorInfo {
     constructor(textColor, foregroundColor, strikeoutColor, underlineColor) {
@@ -9675,6 +10380,7 @@ class LayoutCharacterPropertiesColorInfo {
 
 
 
+
 class CharacterProperties {
     constructor() {
         this.measurerSizes = Object.create(null);
@@ -9809,8 +10515,19 @@ class MaskedCharacterProperties extends CharacterProperties {
             this.useValueExt &= ~this.getHighPartUseValue(mask);
         }
     }
-    setUseValueFull(value) {
-        this.useValue = this.getLowPartUseValue(value);
+    setUseValueFull(value, onlyForDefault = false) {
+        const lowPartUseValue = this.getLowPartUseValue(value);
+        if (onlyForDefault) {
+            character_property_descriptor_CharacterPropertyDescriptor.ALL_FIELDS.forEach((desc) => {
+                const prop = desc.getProp(this);
+                const mask = desc.maskValue();
+                if (desc.binaryEquals(prop, desc.defaultValue))
+                    this.setUseValue(mask, !!(mask & lowPartUseValue));
+            });
+        }
+        else {
+            this.useValue = lowPartUseValue;
+        }
         this.useValueExt = this.getHighPartUseValue(value);
     }
     getLowPartUseValue(value) {
@@ -10224,7 +10941,7 @@ class LayoutBorder extends BorderBase {
 
 class BorderInfo {
     constructor() {
-        this.style = BorderLineStyle.None;
+        this.style = BorderLineStyle.Nil;
         this.color = ColorModelInfoCache.defaultItem;
         this.width = 0;
         this.offset = 0;
@@ -10274,66 +10991,6 @@ class BorderInfo {
     }
 }
 
-// EXTERNAL MODULE: ./node_modules/@devexpress/utils/lib/utils/comparers.js
-var comparers = __webpack_require__(4170);
-;// CONCATENATED MODULE: ./src/common/model/history/base/history-item.ts
-
-class history_item_HistoryItem {
-    canBeMerged() {
-        return false;
-    }
-    constructor(modelManipulator) {
-        this.uniqueId = -1;
-        this.modelManipulator = modelManipulator;
-    }
-    changeModified() {
-        return true;
-    }
-}
-class CompositionHistoryItem extends history_item_HistoryItem {
-    canBeMerged() {
-        return true;
-    }
-    constructor() {
-        super(null);
-        this.historyItems = [];
-    }
-    changeModified() {
-        var item;
-        for (var i = 0; item = this.historyItems[i]; i++) {
-            if (item.changeModified())
-                return true;
-        }
-        return false;
-    }
-    redo() {
-        var item;
-        for (var i = 0; item = this.historyItems[i]; i++)
-            item.redo();
-    }
-    undo() {
-        var item;
-        for (var i = this.historyItems.length - 1; item = this.historyItems[i]; i--)
-            item.undo();
-    }
-    add(historyItem) {
-        if (historyItem == null)
-            throw new Error(lib_errors/* Errors */.D.ValueCannotBeNull);
-        this.historyItems.push(historyItem);
-    }
-}
-
-;// CONCATENATED MODULE: ./src/common/model/history/base/interval-based-history-item.ts
-
-class interval_based_history_item_IntervalBasedHistoryItem extends history_item_HistoryItem {
-    get boundSubDocument() { return this.subDocInterval.subDocument; }
-    get interval() { return this.subDocInterval.interval; }
-    constructor(modelManipulator, subDocInterval) {
-        super(modelManipulator);
-        this.subDocInterval = subDocInterval;
-    }
-}
-
 ;// CONCATENATED MODULE: ./src/common/model/history/items/paragraph-properties-history-items.ts
 
 
@@ -11503,650 +12160,6 @@ class LineSpacingUnit {
     }
 }
 
-;// CONCATENATED MODULE: ./src/common/model/history/items/character-properties-history-items.ts
-
-
-class FontUseValueHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue) {
-        super(modelManipulator, subDocInterval);
-        this.newValue = newValue;
-    }
-    redo() {
-        this.oldState = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, this.newValue);
-    }
-    undo() {
-        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.oldState);
-    }
-}
-class CharacterPropertiesHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue) {
-        super(modelManipulator, subDocInterval);
-        this.newValue = newValue;
-    }
-    redo() {
-        this.oldState = this.modelManipulator.characterProperties.setValue(this.boundSubDocument, this.interval, this.newValue);
-    }
-    undo() {
-        this.modelManipulator.characterProperties.restoreValue(this.boundSubDocument, this.oldState);
-    }
-}
-class CharacterPropertiesHistoryItemBase extends interval_based_history_item_IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue, newUse) {
-        super(modelManipulator, subDocInterval);
-        this.newValue = newValue;
-        this.newUse = newUse;
-    }
-    redo() {
-        this.oldState = this.getPropertiesManipulator().setValue(this.boundSubDocument, this.interval, this.newValue, this.newUse);
-    }
-    undo() {
-        this.getPropertiesManipulator().restoreValue(this.boundSubDocument, this.oldState);
-    }
-    getPropertiesManipulator() {
-        throw new Error(lib_errors/* Errors */.D.NotImplemented);
-    }
-}
-class FontBoldHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontBold;
-    }
-}
-class FontCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontCaps;
-    }
-}
-class FontSmallCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontSmallCaps;
-    }
-}
-class FontUnderlineTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontUnderlineType;
-    }
-}
-class FontTextColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.textColor;
-    }
-}
-class FontShadingInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.shadingInfo;
-    }
-}
-class FontHiddenHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontHidden;
-    }
-}
-class FontItalicHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontItalic;
-    }
-}
-class FontNameHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontName;
-    }
-}
-class FontScriptHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.script;
-    }
-}
-class FontSizeHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontSize;
-    }
-}
-class FontStrikeoutTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontStrikeoutType;
-    }
-}
-class FontStrikeoutWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontStrikeoutWordsOnly;
-    }
-}
-class FontStrikeoutColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontStrikeoutColor;
-    }
-}
-class FontUnderlineColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontUnderlineColor;
-    }
-}
-class FontHighlightColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontHighlightColor;
-    }
-}
-class FontUnderlineWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontUnderlineWordsOnly;
-    }
-}
-class FontNoProofHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontNoProof;
-    }
-}
-class FontLangInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.langInfo;
-    }
-}
-class FontCompositeFontInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.compositeFontInfo;
-    }
-}
-class ResetCharacterPropertiesUseValuesHistoryItem extends (/* unused pure expression or super */ null && (IntervalBasedHistoryItem)) {
-    redo() {
-        this.state = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, 0);
-    }
-    undo() {
-        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.state);
-    }
-}
-
-;// CONCATENATED MODULE: ./src/common/model/character/character-property-descriptor.ts
-
-
-
-
-
-
-
-
-class CharacterPropertiesAllCapsDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.allCaps = newValue;
-    }
-    getProp(props) {
-        return props.allCaps;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseAllCaps;
-    }
-    getHistoryItemConstructor() {
-        return FontCapsHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.AllCaps;
-    }
-}
-class CharacterPropertiesSmallCapsDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.smallCaps = newValue;
-    }
-    getProp(props) {
-        return props.smallCaps;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseSmallCaps;
-    }
-    getHistoryItemConstructor() {
-        return FontSmallCapsHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.SmallCaps;
-    }
-}
-class CharacterPropertiesFontSizeDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = 11;
-    }
-    setProp(props, newValue) {
-        props.fontSize = newValue;
-    }
-    getProp(props) {
-        return props.fontSize;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseDoubleFontSize;
-    }
-    getHistoryItemConstructor() {
-        return FontSizeHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Size;
-    }
-}
-class CharacterPropertiesFontBoldDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.fontBold = newValue;
-    }
-    getProp(props) {
-        return props.fontBold;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontBold;
-    }
-    getHistoryItemConstructor() {
-        return FontBoldHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Bold;
-    }
-}
-class CharacterPropertiesFontItalicDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.fontItalic = newValue;
-    }
-    getProp(props) {
-        return props.fontItalic;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontItalic;
-    }
-    getHistoryItemConstructor() {
-        return FontItalicHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Italic;
-    }
-}
-class CharacterPropertiesFontInfoDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = undefined;
-    }
-    setProp(props, newValue) {
-        props.fontInfo = newValue;
-    }
-    getProp(props) {
-        return props.fontInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontName;
-    }
-    getHistoryItemConstructor() {
-        return FontNameHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.FontName;
-    }
-}
-class CharacterPropertiesScriptDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = CharacterFormattingScript.Normal;
-    }
-    setProp(props, newValue) {
-        props.script = newValue;
-    }
-    getProp(props) {
-        return props.script;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseScript;
-    }
-    getHistoryItemConstructor() {
-        return FontScriptHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Script;
-    }
-}
-class CharacterPropertiesStrikeoutTypeDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = StrikeoutType.None;
-    }
-    setProp(props, newValue) {
-        props.fontStrikeoutType = newValue;
-    }
-    getProp(props) {
-        return props.fontStrikeoutType;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontStrikeoutType;
-    }
-    getHistoryItemConstructor() {
-        return FontStrikeoutTypeHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.StrikeoutType;
-    }
-}
-class CharacterPropertiesUnderlineTypeDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = UnderlineType.None;
-    }
-    setProp(props, newValue) {
-        props.fontUnderlineType = newValue;
-    }
-    getProp(props) {
-        return props.fontUnderlineType;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontUnderlineType;
-    }
-    getHistoryItemConstructor() {
-        return FontUnderlineTypeHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.UnderlineType;
-    }
-}
-class CharacterPropertiesUnderlineWordsOnlyDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.underlineWordsOnly = newValue;
-    }
-    getProp(props) {
-        return props.underlineWordsOnly;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseUnderlineWordsOnly;
-    }
-    getHistoryItemConstructor() {
-        return FontUnderlineWordsOnlyHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.UnderlineWordsOnly;
-    }
-}
-class CharacterPropertiesStrikeoutWordsOnlyDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.strikeoutWordsOnly = newValue;
-    }
-    getProp(props) {
-        return props.strikeoutWordsOnly;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseStrikeoutWordsOnly;
-    }
-    getHistoryItemConstructor() {
-        return FontStrikeoutWordsOnlyHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.StrikeoutWordsOnly;
-    }
-}
-class CharacterPropertiesNoProofDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.noProof = newValue;
-    }
-    getProp(props) {
-        return props.noProof;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseNoProof;
-    }
-    getHistoryItemConstructor() {
-        return FontNoProofHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.NoProof;
-    }
-}
-class CharacterPropertiesHiddenDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.hidden = newValue;
-    }
-    getProp(props) {
-        return props.hidden;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseHidden;
-    }
-    getHistoryItemConstructor() {
-        return FontHiddenHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Hidden;
-    }
-}
-class CharacterPropertiesTextColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.autoColor;
-    }
-    setProp(props, newValue) {
-        props.textColor = newValue;
-    }
-    getProp(props) {
-        return props.textColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseForeColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontTextColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.TextColor;
-    }
-}
-class CharacterPropertiesShadingInfoColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = ShadingInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.shadingInfo = newValue;
-    }
-    getProp(props) {
-        return props.shadingInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseShadingInfoIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontShadingInfoHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.ShadingInfo;
-    }
-}
-class CharacterPropertiesStrikeoutColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.strikeoutColor = newValue;
-    }
-    getProp(props) {
-        return props.strikeoutColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseStrikeoutColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontStrikeoutColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.StrikeoutColor;
-    }
-}
-class CharacterPropertiesUnderlineColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.underlineColor = newValue;
-    }
-    getProp(props) {
-        return props.underlineColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseUnderlineColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontUnderlineColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.UnderlineColor;
-    }
-}
-class CharacterPropertiesHighlightColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.highlightColor = newValue;
-    }
-    getProp(props) {
-        return props.highlightColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseHighlightColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontHighlightColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.HighlightColor;
-    }
-}
-class CharacterPropertiesLangInfoDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = new LangInfo();
-    }
-    setProp(props, newValue) {
-        props.langInfo = newValue;
-    }
-    getProp(props) {
-        return props.langInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseLangInfo;
-    }
-    getHistoryItemConstructor() {
-        return FontLangInfoHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.LangInfo;
-    }
-}
-class CharacterPropertiesCompositeFontInfoDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = new CompositeFontInfo();
-    }
-    setProp(props, newValue) {
-        props.compositeFontInfo = newValue;
-    }
-    getProp(props) {
-        return props.compositeFontInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseCompositeFontInfo;
-    }
-    getHistoryItemConstructor() {
-        return FontCompositeFontInfoHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.CompositeFontInfo;
-    }
-}
-class character_property_descriptor_CharacterPropertyDescriptor {
-}
-character_property_descriptor_CharacterPropertyDescriptor.allCaps = new CharacterPropertiesAllCapsDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.size = new CharacterPropertiesFontSizeDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.bold = new CharacterPropertiesFontBoldDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.italic = new CharacterPropertiesFontItalicDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.fontInfo = new CharacterPropertiesFontInfoDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.script = new CharacterPropertiesScriptDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.strikeoutType = new CharacterPropertiesStrikeoutTypeDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.underlineType = new CharacterPropertiesUnderlineTypeDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly = new CharacterPropertiesUnderlineWordsOnlyDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly = new CharacterPropertiesStrikeoutWordsOnlyDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.noProof = new CharacterPropertiesNoProofDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.hidden = new CharacterPropertiesHiddenDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.langInfo = new CharacterPropertiesLangInfoDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo = new CharacterPropertiesCompositeFontInfoDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.textColor = new CharacterPropertiesTextColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.shadingInfo = new CharacterPropertiesShadingInfoColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.highlightColor = new CharacterPropertiesHighlightColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor = new CharacterPropertiesStrikeoutColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.underlineColor = new CharacterPropertiesUnderlineColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.smallCaps = new CharacterPropertiesSmallCapsDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.ALL_FIELDS = [
-    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
-    character_property_descriptor_CharacterPropertyDescriptor.size,
-    character_property_descriptor_CharacterPropertyDescriptor.bold,
-    character_property_descriptor_CharacterPropertyDescriptor.italic,
-    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.script,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineType,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.noProof,
-    character_property_descriptor_CharacterPropertyDescriptor.hidden,
-    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.textColor,
-    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.highlightColor,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
-    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
-];
-character_property_descriptor_CharacterPropertyDescriptor.whatNeedSetWhenCreateHyperlinkField = [
-    character_property_descriptor_CharacterPropertyDescriptor.size,
-    character_property_descriptor_CharacterPropertyDescriptor.bold,
-    character_property_descriptor_CharacterPropertyDescriptor.italic,
-    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.script,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
-    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.noProof,
-    character_property_descriptor_CharacterPropertyDescriptor.hidden,
-    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
-    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
-];
-
 ;// CONCATENATED MODULE: ./src/common/model/borders/table-border-base.ts
 
 class TableBordersBase {
@@ -12329,6 +12342,7 @@ var ConditionalTableStyleFormatting;
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["TopLeftCell"] = 4] = "TopLeftCell";
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["BottomRightCell"] = 2] = "BottomRightCell";
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["BottomLeftCell"] = 1] = "BottomLeftCell";
+    ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["None"] = 0] = "None";
 })(ConditionalTableStyleFormatting || (ConditionalTableStyleFormatting = {}));
 
 ;// CONCATENATED MODULE: ./src/common/model/tables/secondary-structures/table-units.ts
@@ -16430,6 +16444,8 @@ class CacheImageInfo {
     static get emptyPictureSize() { return new geometry_size.Size(CacheImageInfo.emptyPicDimension, CacheImageInfo.emptyPicDimension); }
     get isLoaded() { return this._referenceInfo ? this._referenceInfo._isLoaded : this._isLoaded; }
     set isLoaded(val) { this._isLoaded = val; }
+    get isSizeDefined() { return this._referenceInfo ? this._referenceInfo._isSizeDefined : this._isSizeDefined; }
+    set isSizeDefined(val) { this._isSizeDefined = val; }
     get size() { return this._referenceInfo ? this._referenceInfo._size : this._size; }
     set size(val) { this._size = val; }
     get currId() { return this.actualId !== undefined ? this.actualId : this.tmpId; }
@@ -16442,15 +16458,17 @@ class CacheImageInfo {
         this._base64 = undefined;
         this._size = undefined;
         this._isLoaded = undefined;
+        this._isSizeDefined = undefined;
         this.file = undefined;
     }
-    constructor(base64, actualId, tmpId, imageUrl, file, referenceInfo, size, isLoaded) {
+    constructor(base64, actualId, tmpId, imageUrl, file, referenceInfo, size, isLoaded, isActualSize) {
         this._base64 = base64 !== undefined ? utils_base64.Base64Utils.normalizeToDataUrl(base64, "image/png") : undefined;
         this.actualId = actualId;
         this.tmpId = tmpId;
         this._referenceInfo = referenceInfo;
         this._size = size ? size : CacheImageInfo.emptyPictureSize;
         this._isLoaded = isLoaded !== undefined ? isLoaded : false;
+        this._isSizeDefined = isActualSize ? isActualSize : !!size;
         this.imageUrl = imageUrl;
         this.file = file;
     }
@@ -16464,7 +16482,7 @@ class CacheImageInfo {
                 this.size.equals(obj.size);
     }
     clone() {
-        return new CacheImageInfo(this._base64, this.actualId, this.tmpId, this.imageUrl, this.file, this._referenceInfo, this._size, this._isLoaded);
+        return new CacheImageInfo(this._base64, this.actualId, this.tmpId, this.imageUrl, this.file, this._referenceInfo, this._size, this._isLoaded, this._isSizeDefined);
     }
     shouldMakeImagePdfCompatible() {
         if ((0,common.isDefined)(this._convertedBase64))
@@ -19210,8 +19228,6 @@ class TableAlignmentApplier {
                 offset = 0;
                 break;
         }
-        if (offset <= 0)
-            return;
         TableAlignmentApplier.moveAllTable(currTableColumnInfo, (rect) => rect.x += offset);
     }
     static applyCellsVerticalAlignment(defaultTableCellProps, grid, currTableColumnInfo, rowInfo) {
@@ -19721,9 +19737,10 @@ class TabInfoBase {
     }
 }
 class TabInfo extends TabInfoBase {
-    constructor(position, alignment, leader, deleted, isDefault) {
+    constructor(position, alignment, leader, deleted, isDefault, isParagraphIndent = false) {
         super(alignment, leader, deleted, isDefault);
         this.position = position;
+        this.isParagraphIndent = isParagraphIndent;
     }
     equals(obj) {
         return super.equals(obj) && this.position == obj.position;
@@ -22661,6 +22678,7 @@ var ModelChangeType;
     ModelChangeType[ModelChangeType["TableCellInserted"] = 66] = "TableCellInserted";
     ModelChangeType[ModelChangeType["RangePermissionsChanged"] = 67] = "RangePermissionsChanged";
     ModelChangeType[ModelChangeType["RangePermissionsPropertiesChanged"] = 68] = "RangePermissionsPropertiesChanged";
+    ModelChangeType[ModelChangeType["ZoomLevelChanged"] = 69] = "ZoomLevelChanged";
 })(ModelChangeType || (ModelChangeType = {}));
 
 ;// CONCATENATED MODULE: ./src/common/model/changes/sub-document/field/deleted.ts
@@ -22965,15 +22983,16 @@ class Field {
             return newInterval.start = Field.correctIntervalDueToFieldsCaseSelectionCollapsed(subDocument.fields, newInterval.start);
         const indexesInterval = Field.correctIntervalDueToFieldsWithoutUiChecks(subDocument, newInterval);
         utils_list.ListUtils.forEach(fields, (field) => {
-            if (field.getResultInterval().equals(newInterval) && !this.isFloatingObjectSelected(subDocument, newInterval))
+            if (field.getResultInterval().equals(newInterval) && !this.isResizableObjectSelected(subDocument, newInterval))
                 newInterval.expand(field.getAllFieldInterval());
         }, indexesInterval.start, indexesInterval.end);
     }
-    static isFloatingObjectSelected(subDocument, interval) {
+    static isResizableObjectSelected(subDocument, interval) {
         if (interval.length !== 1)
             return false;
         const run = subDocument.getRunByPosition(interval.start);
-        return run && (run.getType() == RunType.AnchoredPictureRun || run.getType() == RunType.AnchoredTextBoxRun);
+        const runType = run && run.getType();
+        return runType == RunType.AnchoredPictureRun || runType == RunType.AnchoredTextBoxRun || runType == RunType.InlinePictureRun;
     }
     static correctWhenPositionInStartCode(fields, position) {
         if (fields.length < 1)
@@ -32162,6 +32181,14 @@ class LayoutOtherPageAreasInfo {
     }
 }
 class LayoutPage extends rectangle.Rectangle {
+    get grids() {
+        const result = new Map();
+        for (let pageArea of this.mainSubDocumentPageAreas)
+            pageArea.grids.forEach((grid, table) => result.set(table, grid));
+        for (let pageArea of Object.values(this.otherPageAreas))
+            pageArea.grids.forEach((grid, table) => result.set(table, grid));
+        return result;
+    }
     constructor() {
         super(0, 0, 0, 0);
         this.mainSubDocumentPageAreas = [];
@@ -34167,7 +34194,7 @@ class FieldsWaitingForUpdate {
                     }
                     if (!fieldParser.update(response)) {
                         someFieldInCurrentInfoNotUpdated = true;
-                        info.parsers.push(fieldParser);
+                        info.parsers.unshift(fieldParser);
                     }
                     else
                         fieldParser.destructor();
@@ -36096,7 +36123,7 @@ function convertToCharacterPropertiesApi(properties, colorProvider) {
     return value;
 }
 function convertFromCharacterPropertiesApi(properties, fontInfoCache, parameterIndex, setRestAsUndefined, propsCoreTemplate) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     properties = ApiParametersChecker.check(properties, parameterIndex, false, [
         ApiParametersChecker.objectDescriptor('properties', 'CharacterProperties', (val) => val)
     ]);
@@ -36116,31 +36143,27 @@ function convertFromCharacterPropertiesApi(properties, fontInfoCache, parameterI
     propsCoreTemplate.fontItalic = (_d = ApiParametersChecker.check(properties.italic, parameterIndex, true, [
         ApiParametersChecker.booleanDescriptor('properties.italic', (val) => val)
     ])) !== null && _d !== void 0 ? _d : propsCoreTemplate.fontItalic;
-    propsCoreTemplate.fontInfo = (_e = ApiParametersChecker.check(properties.fontName, parameterIndex, true, [
-        ApiParametersChecker.stringDescriptor('properties.fontName', (val) => {
-            const fontInfo = fontInfoCache.getItemByName(val);
-            if (!fontInfo)
-                throw Error('Unknown font name');
-            return fontInfo;
-        }, false)
-    ])) !== null && _e !== void 0 ? _e : propsCoreTemplate.fontInfo;
-    propsCoreTemplate.fontSize = (_f = ApiParametersChecker.check(properties.size, parameterIndex, true, [
+    const fontInfo = ApiParametersChecker.check(properties.fontName, parameterIndex, true, [
+        ApiParametersChecker.stringDescriptor('properties.fontName', (value) => fontInfoCache.getItemByName(value), false)
+    ]);
+    propsCoreTemplate.fontInfo = fontInfo === undefined ? propsCoreTemplate.fontInfo : fontInfo !== null && fontInfo !== void 0 ? fontInfo : fontInfoCache.addFont(properties.fontName, properties.fontName);
+    propsCoreTemplate.fontSize = (_e = ApiParametersChecker.check(properties.size, parameterIndex, true, [
         ApiParametersChecker.numberDescriptor('properties.size', (val) => val, 0, 601)
-    ])) !== null && _f !== void 0 ? _f : propsCoreTemplate.fontSize;
-    propsCoreTemplate.hidden = (_g = ApiParametersChecker.check(properties.hidden, parameterIndex, true, [
+    ])) !== null && _e !== void 0 ? _e : propsCoreTemplate.fontSize;
+    propsCoreTemplate.hidden = (_f = ApiParametersChecker.check(properties.hidden, parameterIndex, true, [
         ApiParametersChecker.booleanDescriptor('properties.hidden', (val) => val)
-    ])) !== null && _g !== void 0 ? _g : propsCoreTemplate.hidden;
+    ])) !== null && _f !== void 0 ? _f : propsCoreTemplate.hidden;
     const shadigInfoColor = ApiParametersChecker.check(properties.backColor, parameterIndex, true, ModelParametersChecker.colorDescriptors('properties.backColor'));
     propsCoreTemplate.shadingInfo = shadigInfoColor === undefined ? propsCoreTemplate.shadingInfo :
         ShadingInfo.createByColor(color_model_info_ColorModelInfo.makeByColor(shadigInfoColor));
-    propsCoreTemplate.script = (_h = ApiParametersChecker.check(properties.script, parameterIndex, true, [
+    propsCoreTemplate.script = (_g = ApiParametersChecker.check(properties.script, parameterIndex, true, [
         ApiParametersChecker.enumDescriptor('properties.script', (val) => val, CharacterPropertiesScriptApi, 'CharacterPropertiesScript')
-    ])) !== null && _h !== void 0 ? _h : propsCoreTemplate.script;
+    ])) !== null && _g !== void 0 ? _g : propsCoreTemplate.script;
     const underlineColor = ApiParametersChecker.check(properties.underlineColor, parameterIndex, true, ModelParametersChecker.colorDescriptors('properties.underlineColor'));
     propsCoreTemplate.underlineColor = underlineColor === undefined ? propsCoreTemplate.underlineColor : color_model_info_ColorModelInfo.makeByColor(underlineColor);
-    propsCoreTemplate.underlineWordsOnly = (_j = ApiParametersChecker.check(properties.underlineWordsOnly, parameterIndex, true, [
+    propsCoreTemplate.underlineWordsOnly = (_h = ApiParametersChecker.check(properties.underlineWordsOnly, parameterIndex, true, [
         ApiParametersChecker.booleanDescriptor('properties.underlineWordsOnly', (val) => val)
-    ])) !== null && _j !== void 0 ? _j : propsCoreTemplate.underlineWordsOnly;
+    ])) !== null && _h !== void 0 ? _h : propsCoreTemplate.underlineWordsOnly;
     const strikeout = ApiParametersChecker.check(properties.strikeout, parameterIndex, true, [
         ApiParametersChecker.booleanDescriptor('properties.strikeout', (val) => val)
     ]);
@@ -40501,7 +40524,7 @@ class CharacterPropertiesUseValueManipulator {
     constructor(manipulator) {
         this.manipulator = manipulator;
     }
-    setValue(subDocument, interval, newValue) {
+    setValue(subDocument, interval, newValue, keepCustomFormatting = false) {
         var oldState = new HistoryItemIntervalState();
         if (!ControlOptions.isEnabled(subDocument.documentModel.options.characterFormatting))
             return oldState;
@@ -40511,7 +40534,7 @@ class CharacterPropertiesUseValueManipulator {
             var run = iterator.currentRun;
             oldState.register(new HistoryItemIntervalStateObject(iterator.currentInterval(), run.maskedCharacterProperties.getUseValueFull()));
             var properties = run.maskedCharacterProperties.clone();
-            properties.setUseValueFull(newValue);
+            properties.setUseValueFull(newValue, keepCustomFormatting);
             run.setCharacterProperties(properties);
             run.onCharacterPropertiesChanged();
         }
@@ -43195,7 +43218,7 @@ class PictureManipulator extends RunsBaseManipulator {
             this.history.addTransaction(() => {
                 this.modelManipulator.range.removeInterval(new SubDocumentInterval(subDocument, interval), true, false);
                 const newInfo = new InlinePictureInfo(pictureRun.size.clone(), new Shape(), -1, pictureRun.info.containerProperties, pictureRun.info.nonVisualDrawingProperties);
-                this.modelManipulator.picture.insertInlinePictureViaHistory(new SubDocumentPosition(subDocument, interval.start), charPropsBundle, newInfo);
+                this.modelManipulator.picture.insertInlinePictureViaHistory(new SubDocumentPosition(subDocument, interval.start), charPropsBundle, newInfo, new ImageLoadingOptions(!pictureRun.cacheInfo.isSizeDefined));
             });
         }
     }
@@ -43210,7 +43233,7 @@ class PictureManipulator extends RunsBaseManipulator {
             anchorInfo.zOrder = this.modelManipulator.floatingObject.zOrder.getNewZOrder(subDocument);
             this.modelManipulator.range.removeInterval(new SubDocumentInterval(subDocument, interval), true, false);
             const newInfo = new AnchorPictureInfo(pictureRun.size.clone(), new Shape(), anchorInfo, pictureRun.info.containerProperties, pictureRun.info.nonVisualDrawingProperties);
-            this.modelManipulator.picture.insertAnchoredPictureViaHistory(new SubDocumentPosition(subDocument, interval.start), charPropsBundle, newInfo, new ImageLoadingOptions(false));
+            this.modelManipulator.picture.insertAnchoredPictureViaHistory(new SubDocumentPosition(subDocument, interval.start), charPropsBundle, newInfo, new ImageLoadingOptions(!pictureRun.cacheInfo.isSizeDefined));
             run = subDocument.getRunByPosition(interval.start);
         }
         let anchoredRun = run.getType() == RunType.AnchoredPictureRun ? run : run;
@@ -45979,6 +46002,10 @@ class ModelManipulator {
     notifyModelChanged(change) {
         this.modelListeners.forEach(listener => listener.modelChanged(change));
     }
+    addModelListener(listener) {
+        if (this.modelListeners.indexOf(listener) < 0)
+            this.modelListeners.push(listener);
+    }
     removeModelListener(listener) {
         const index = this.modelListeners.indexOf(listener);
         if (index >= 0)
@@ -50040,11 +50067,13 @@ class RtfStyleExporter {
 
 
 
+
 class RtfTableExporterStateBase {
-    constructor(rtfExporter, table, nestingLevel) {
+    constructor(rtfExporter, table, grid, nestingLevel) {
         this.rtfExporter = rtfExporter;
         this._nestingLevel = nestingLevel;
         this.table = table;
+        this.grid = grid;
         this.tableRowPropertiesExporter = new RtfTableRowPropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
         this.tableCellPropertiesExporter = new RtfTableCellPropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
         this.tablePropertiesExporter = new RtfTablePropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
@@ -50119,7 +50148,7 @@ class RtfTableExporterStateBase {
         while (parentCell !== nestedTable.parentCell) {
             nestedTable = nestedTable.parentCell.parentRow.parentTable;
         }
-        return RtfTableExporter.exportNestedTable(this.rtfExporter, nestedTable, this.nestingLevel + 1);
+        return RtfTableExporter.exportNestedTable(this.rtfExporter, nestedTable, this.grid, this.nestingLevel + 1);
     }
     exportRowProperties(row, rowIndex) {
         const rowLeft = this.calculateRowLeft(row, row.parentTable.getActualTableIndent(this.documentModel.defaultTableProperties));
@@ -50127,20 +50156,25 @@ class RtfTableExporterStateBase {
         let cellRightVirtualColInd = row.gridBefore;
         for (const cell of row.cells) {
             cellRightVirtualColInd += cell.columnSpan;
-            const cellRight = rowLeft + this.getCellWidth(cellRightVirtualColInd);
+            const cellWidth = this.getCellWidth(row.gridBefore, cellRightVirtualColInd);
+            const cellRight = unit_converter/* UnitConverter */.u.pixelsToTwips(rowLeft + cellWidth);
             this.exportCellProperties(cell, cellRight);
         }
     }
-    getCellWidth(virtualColumnIndex) {
-        if (virtualColumnIndex < 0)
+    getCellWidth(leftSideIndex, columnSpan) {
+        if (leftSideIndex < 0 || columnSpan < 0)
             throw new Error(lib_errors/* Errors */.D.InternalException);
-        const minVirtualColumnWidth = 10;
-        return virtualColumnIndex * minVirtualColumnWidth;
+        let result = 0;
+        for (let i = 0; i < columnSpan; i++)
+            result += Math.max(this.grid.columns.width[i + leftSideIndex], 1);
+        return result;
     }
     calculateRowLeft(row, indent) {
-        const widthBefore = row.gridBefore > 0 ? this.getCellWidth(row.gridBefore) : 0;
+        var _a;
+        const widthBefore = row.gridBefore > 0 ? this.getCellWidth(0, row.gridBefore) : 0;
         const offset = this.getActualWidth(indent) + widthBefore;
-        return offset - (this.rowLeftOffset != null ? this.rowLeftOffset : this.calculateRowLeftOffset(row));
+        const rowLeftOffset = (_a = this.rowLeftOffset) !== null && _a !== void 0 ? _a : this.calculateRowLeftOffset(row);
+        return offset - rowLeftOffset;
     }
     calculateRowLeftOffset(row) {
         const borderWidth = row.cells[0].properties.borders.left.width;
@@ -50250,8 +50284,8 @@ class RtfTableExporterStateBase {
 
 
 class RtfNestedTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter, table, nestingLevel) {
-        super(rtfExporter, table, nestingLevel);
+    constructor(rtfExporter, table, grid, nestingLevel) {
+        super(rtfExporter, table, grid, nestingLevel);
     }
     export() {
         super.exportBase();
@@ -50280,8 +50314,8 @@ class RtfNestedTableExporterState extends RtfTableExporterStateBase {
 
 
 class RtfTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter, table) {
-        super(rtfExporter, table, 1);
+    constructor(rtfExporter, table, grid) {
+        super(rtfExporter, table, grid, 1);
     }
     export() {
         super.exportBase();
@@ -50300,13 +50334,13 @@ class RtfTableExporterState extends RtfTableExporterStateBase {
 
 
 class RtfTableExporter {
-    static exportTable(rtfContentExporter, table) {
-        new RtfTableExporterState(rtfContentExporter, table).export();
+    static exportTable(rtfContentExporter, table, grid) {
+        new RtfTableExporterState(rtfContentExporter, table, grid).export();
         rtfContentExporter.tableIterator.update(table.getEndPosition());
         return rtfContentExporter.subDocument.getParagraphIndexByPosition(table.getEndPosition() - 1);
     }
-    static exportNestedTable(rtfContentExporter, table, nestingLevel) {
-        new RtfNestedTableExporterState(rtfContentExporter, table, nestingLevel).export();
+    static exportNestedTable(rtfContentExporter, table, grid, nestingLevel) {
+        new RtfNestedTableExporterState(rtfContentExporter, table, grid, nestingLevel).export();
         rtfContentExporter.tableIterator.update(table.getEndPosition());
         return rtfContentExporter.subDocument.getParagraphIndexByPosition(table.getEndPosition() - 1);
     }
@@ -50352,17 +50386,18 @@ class RtfTableExporter {
 class RtfContentExporter {
     get shouldExportHiddenText() { return true; }
     ;
-    constructor(documentModel, options, rtfExportHelper) {
+    get documentModel() { return this.exportModelOptions.modelManager.modelManipulator.model; }
+    constructor(exportModelOptions, options, rtfExportHelper) {
         this.shouldFourceUpdateIterators = false;
-        this.documentModel = documentModel;
+        this.exportModelOptions = exportModelOptions;
         this.subDocument = this.documentModel.mainSubDocument;
         this.pieceTableNumberingListCounters = new PieceTableNumberingListCountersManager();
         this.rtfExportHelper = rtfExportHelper;
         this.options = options;
         this.rtfBuilder = this.createRtfBuilder();
-        this.paragraphPropertiesExporter = new RtfParagraphPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder);
-        this.characterPropertiesExporter = new RtfCharacterPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder, options);
-        this.sectionPropertiesExporter = new RtfSectionPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder);
+        this.paragraphPropertiesExporter = new RtfParagraphPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder);
+        this.characterPropertiesExporter = new RtfCharacterPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder, options);
+        this.sectionPropertiesExporter = new RtfSectionPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder);
         this.runHandlerMap = new MapCreator()
             .add(RunType.TextRun, this.exportTextRun)
             .add(RunType.FieldCodeStartRun, this.fieldCodeStartRunHandler)
@@ -50572,7 +50607,7 @@ class RtfContentExporter {
             value = "00000000";
         }
         else {
-            const view = new DataView(hash, 0);
+            const view = new DataView(hash.buffer, 0);
             const hashValue = view.getInt32(0);
             value = this.documentModel.simpleFormattersManager.formatString("{0:x8}", hashValue);
         }
@@ -50748,11 +50783,14 @@ class RtfContentExporter {
             this.exportSingleParagraph(paragraph);
             return paragraphIndex;
         }
-        else
-            return RtfTableExporter.exportTable(this, tablesInfo[0].table.getTopLevelParent()) - this.startSectionParagraphIndex;
+        else {
+            const table = tablesInfo[0].table.getTopLevelParent();
+            const grid = this.exportModelOptions.grids.get(table);
+            return RtfTableExporter.exportTable(this, table, grid) - this.startSectionParagraphIndex;
+        }
     }
     exportSingleParagraph(paragraph) {
-        this.exportParagraphCore(paragraph, 0, 0, -1);
+        this.exportParagraphCore(paragraph, 0, ConditionalTableStyleFormatting.None, -1);
         this.finishParagraph(paragraph);
     }
     finishParagraph(paragraph) {
@@ -51282,11 +51320,11 @@ class RtfExportHelper {
 
 class RtfExporter {
     get documentModel() { return this.modelManipulator.model; }
-    constructor(modelManipulator, options) {
-        this.modelManipulator = modelManipulator;
+    constructor(exportModelOptions, options) {
+        this.modelManipulator = exportModelOptions.modelManager.modelManipulator;
         this.options = options;
         this.rtfExportHelper = new RtfExportHelper();
-        this.contentExporter = new RtfContentExporter(this.documentModel, options, this.rtfExportHelper);
+        this.contentExporter = new RtfContentExporter(exportModelOptions, options, this.rtfExportHelper);
         this.rtfBuilder = this.contentExporter.createRtfBuilder();
     }
     exportToBlob(callback) {
@@ -51698,6 +51736,7 @@ NumberingHelper.templateCodeEnd = 0x7FFFFFFF;
 
 
 
+
 
 
 class ModelCreator {
@@ -51795,6 +51834,11 @@ class ModelCreator {
         }
         if (this.options.fillTableStyles) {
             const tableConditionalStyle = new TableConditionalStyle(templateTableProp, templateTableRowProp, templateTableCellProp, templateParProp, templateCharProps, templateTabProp);
+            tableConditionalStyle.tableProperties.cellMargins.left.type = TableWidthUnitType.ModelUnits;
+            tableConditionalStyle.tableProperties.cellMargins.left.value = 108;
+            tableConditionalStyle.tableProperties.cellMargins.right.type = TableWidthUnitType.ModelUnits;
+            tableConditionalStyle.tableProperties.cellMargins.right.value = 108;
+            tableConditionalStyle.tableProperties.mask = TablePropertiesMask.UseLeftMargin | TablePropertiesMask.UseRightMargin;
             model.stylesManager.addTableStyle(new TableStyle(TableStyle.DEFAULT_STYLENAME, TableStyle.DEFAULT_STYLENAME, false, false, false, true, {}, tableConditionalStyle, null));
         }
         if (this.options.initOfficeTheme)
@@ -61276,6 +61320,98 @@ class RtfTableColumnsCalculator {
     }
 }
 
+;// CONCATENATED MODULE: ./src/common/formats/rtf/import/table/normalization/apply-use-values.ts
+
+
+
+function applyTablePropertiesUseValues(props, styleProps) {
+    props.mask = TablePropertiesMask.UseNone;
+    if (!props.borders.left.equals(styleProps.borders.left))
+        props.setUseValue(TablePropertiesMask.UseLeftBorder, true);
+    if (!props.borders.top.equals(styleProps.borders.top))
+        props.setUseValue(TablePropertiesMask.UseTopBorder, true);
+    if (!props.borders.right.equals(styleProps.borders.right))
+        props.setUseValue(TablePropertiesMask.UseRightBorder, true);
+    if (!props.borders.bottom.equals(styleProps.borders.bottom))
+        props.setUseValue(TablePropertiesMask.UseBottomBorder, true);
+    if (!props.borders.insideHorizontal.equals(styleProps.borders.insideHorizontal))
+        props.setUseValue(TablePropertiesMask.UseInsideHorizontalBorder, true);
+    if (!props.borders.insideVertical.equals(styleProps.borders.insideVertical))
+        props.setUseValue(TablePropertiesMask.UseInsideVerticalBorder, true);
+    if (!props.cellMargins.left.equals(styleProps.cellMargins.left))
+        props.setUseValue(TablePropertiesMask.UseLeftMargin, true);
+    if (!props.cellMargins.top.equals(styleProps.cellMargins.top))
+        props.setUseValue(TablePropertiesMask.UseTopMargin, true);
+    if (!props.cellMargins.right.equals(styleProps.cellMargins.right))
+        props.setUseValue(TablePropertiesMask.UseRightMargin, true);
+    if (!props.cellMargins.bottom.equals(styleProps.cellMargins.bottom))
+        props.setUseValue(TablePropertiesMask.UseBottomMargin, true);
+    if (!props.cellSpacing.equals(styleProps.cellSpacing))
+        props.setUseValue(TablePropertiesMask.UseCellSpacing, true);
+    if (!props.indent.equals(styleProps.indent))
+        props.setUseValue(TablePropertiesMask.UseTableIndent, true);
+    if (props.tableStyleColumnBandSize != styleProps.tableStyleColumnBandSize)
+        props.setUseValue(TablePropertiesMask.UseTableStyleColBandSize, true);
+    if (props.tableStyleRowBandSize != styleProps.tableStyleRowBandSize)
+        props.setUseValue(TablePropertiesMask.UseTableStyleRowBandSize, true);
+    if (props.avoidDoubleBorders != styleProps.avoidDoubleBorders)
+        props.setUseValue(TablePropertiesMask.UseAvoidDoubleBorders, true);
+    if (props.layoutType != styleProps.layoutType)
+        props.setUseValue(TablePropertiesMask.UseTableLayout, true);
+    if (!props.shadingInfo.equals(styleProps.shadingInfo))
+        props.setUseValue(TablePropertiesMask.UseShadingInfoIndex, true);
+    if (props.tableRowAlignment != styleProps.tableRowAlignment)
+        props.setUseValue(TablePropertiesMask.UseTableAlignment, true);
+    if (props.isTableOverlap != styleProps.isTableOverlap)
+        props.setUseValue(TablePropertiesMask.UseIsTableOverlap, true);
+}
+function applyTableRowPropertiesUseValues(props, styleProps) {
+    props.mask = TableRowPropertiesMask.UseNone;
+    if (!props.cellSpacing.equals(styleProps.cellSpacing))
+        props.setUseValue(TableRowPropertiesMask.UseCellSpacing, true);
+    if (props.cantSplit != styleProps.cantSplit)
+        props.setUseValue(TableRowPropertiesMask.UseCantSplit, true);
+    if (props.hideCellMark != styleProps.hideCellMark)
+        props.setUseValue(TableRowPropertiesMask.UseHideCellMark, true);
+    if (props.tableRowAlignment != styleProps.tableRowAlignment)
+        props.setUseValue(TableRowPropertiesMask.UseTableRowAlignment, true);
+    if (props.header != styleProps.header)
+        props.setUseValue(TableRowPropertiesMask.UseHeader, true);
+    if (props.divId != styleProps.divId)
+        props.setUseValue(TableRowPropertiesMask.UseDivId, true);
+}
+function applyTableCellPropertiesUseValues(props, styleProps) {
+    props.mask = TableCellPropertiesMask.UseNone;
+    if (!props.cellMargins.left.equals(styleProps.cellMargins.left))
+        props.setUseValue(TableCellPropertiesMask.UseLeftMargin, true);
+    if (!props.cellMargins.top.equals(styleProps.cellMargins.top))
+        props.setUseValue(TableCellPropertiesMask.UseTopMargin, true);
+    if (!props.cellMargins.bottom.equals(styleProps.cellMargins.bottom))
+        props.setUseValue(TableCellPropertiesMask.UseBottomMargin, true);
+    if (!props.cellMargins.right.equals(styleProps.cellMargins.right))
+        props.setUseValue(TableCellPropertiesMask.UseRightMargin, true);
+    if (!props.borders.left.equals(styleProps.borders.left))
+        props.setUseValue(TableCellPropertiesMask.UseLeftBorder, true);
+    if (!props.borders.top.equals(styleProps.borders.top))
+        props.setUseValue(TableCellPropertiesMask.UseTopBorder, true);
+    if (!props.borders.bottom.equals(styleProps.borders.bottom))
+        props.setUseValue(TableCellPropertiesMask.UseBottomBorder, true);
+    if (!props.borders.right.equals(styleProps.borders.right))
+        props.setUseValue(TableCellPropertiesMask.UseRightBorder, true);
+    if (props.hideCellMark != styleProps.hideCellMark)
+        props.setUseValue(TableCellPropertiesMask.UseHideCellMark, true);
+    if (props.noWrap != styleProps.noWrap)
+        props.setUseValue(TableCellPropertiesMask.UseNoWrap, true);
+    if (props.fitText != styleProps.fitText)
+        props.setUseValue(TableCellPropertiesMask.UseFitText, true);
+    if (props.textDirection != styleProps.textDirection)
+        props.setUseValue(TableCellPropertiesMask.UseTextDirection, true);
+    if (props.verticalAlignment != styleProps.verticalAlignment)
+        props.setUseValue(TableCellPropertiesMask.UseVerticalAlignment, true);
+    if (!props.shadingInfo.equals(styleProps.shadingInfo))
+        props.setUseValue(TableCellPropertiesMask.UseShadingInfoIndex, true);
+}
+
 ;// CONCATENATED MODULE: ./src/common/formats/rtf/import/table/table-converter.ts
 
 
@@ -61286,6 +61422,7 @@ class RtfTableColumnsCalculator {
 
 
 
+
 class RtfTableConverter {
     constructor(tableReader) {
         this.rtfCellMap = {};
@@ -61333,8 +61470,9 @@ class RtfTableConverter {
             tablePreferredWidth.type = TableWidthUnitType.Auto;
             tablePreferredWidth.value = 0;
         }
-        if (!table.properties.coreProperties.getUseValue(TablePropertiesMask.UseRightMargin) &&
-            !table.properties.coreProperties.getUseValue(TablePropertiesMask.UseLeftMargin) && table.properties.useHalfSpace) {
+        const useMargins = table.properties.coreProperties.getUseValue(TablePropertiesMask.UseLeftMargin) &&
+            table.properties.coreProperties.getUseValue(TablePropertiesMask.UseRightMargin);
+        if (!useMargins && table.properties.useHalfSpace) {
             const margin = table.properties.halfSpace;
             table.properties.coreProperties.cellMargins.left.type = TableWidthUnitType.ModelUnits;
             table.properties.coreProperties.cellMargins.left.value = margin;
@@ -61378,6 +61516,7 @@ class RtfTableConverter {
         return 0;
     }
     convertTableCore(table, rtfTable) {
+        applyTablePropertiesUseValues(table.properties, table.style.baseConditionalStyle.tableProperties);
         const tableGrid = this.calculateTableGrid(rtfTable);
         const rows = table.rows;
         const tableLayoutType = table.properties.layoutType;
@@ -61480,6 +61619,7 @@ class RtfTableConverter {
         return result;
     }
     convertRow(row, rtfRow) {
+        applyTableRowPropertiesUseValues(row.properties, row.parentTable.style.baseConditionalStyle.tableRowProperties);
         const rtfCells = rtfRow.cells;
         for (let i = 0; i < rtfCells.length; i++)
             this.convertCell(row, rtfCells[i]);
@@ -61488,6 +61628,7 @@ class RtfTableConverter {
         if (rtfCell.properties.horizontalMerging == TableCellMergingState.Restart)
             this.mergeCells(rtfCell);
         const cell = rtfCell.createCell(row, this.subDocument);
+        applyTableCellPropertiesUseValues(cell.properties, cell.parentRow.parentTable.style.baseConditionalStyle.tableCellProperties);
         row.cells.push(cell);
         this.rtfCellMap[rtfCell.idForParentCellMap] = cell;
     }
@@ -65405,10 +65546,11 @@ function getAfterInsertReject(callback) {
 
 
 
-function getRtfFromSubDocumentPublic(richOptions, subDocument, coreInterval) {
+function getRtfFromSubDocumentPublic(processor, subDocument, coreInterval) {
     const rangeCopy = RangeCopy.create(new SubDocumentIntervals(subDocument, [coreInterval]));
-    const newModelManager = new ClientModelManager(rangeCopy.model, richOptions, new batch_updatable/* EmptyBatchUpdatableObject */.m1());
-    return new RtfExporter(newModelManager.modelManipulator, new RtfDocumentExporterOptions()).exportAsString();
+    const newModelManager = new ClientModelManager(rangeCopy.model, processor.modelManager.richOptions, new batch_updatable/* EmptyBatchUpdatableObject */.m1());
+    const exportModelOptions = processor.getExportModelOptions({ modelManager: newModelManager });
+    return new RtfExporter(exportModelOptions, new RtfDocumentExporterOptions()).exportAsString();
 }
 function insertRtfInSubDocumentPublic(processor, subDocument, position, rtf, callback) {
     const options = new RtfImporterOptions(() => { });
@@ -70633,9 +70775,104 @@ var SelectionBatchUpdateEvents;
     SelectionBatchUpdateEvents[SelectionBatchUpdateEvents["MisspelledSelectionChanged"] = 8] = "MisspelledSelectionChanged";
 })(SelectionBatchUpdateEvents || (SelectionBatchUpdateEvents = {}));
 
+;// CONCATENATED MODULE: ./src/common/utils/mixed-size.ts
+
+class MixedSize {
+    constructor() {
+        this._UISizePart = 0;
+        this._layoutSizePart = 0;
+        this._scale = 1;
+        this._scaleIsSpecified = false;
+    }
+    static fromLayout(value) {
+        return new MixedSize().addLayoutSize(value);
+    }
+    static fromUI(value) {
+        return new MixedSize().addUISize(value);
+    }
+    get UISize() {
+        this.checkScaleIsSpecified();
+        if (!(0,common.isDefined)(this._UISize))
+            this._UISize = this._layoutSizePart * this._scale + this._UISizePart;
+        return this._UISize;
+    }
+    get LayoutSize() {
+        this.checkScaleIsSpecified();
+        if (!(0,common.isDefined)(this._layoutSize))
+            this._layoutSize = this._layoutSizePart + this._UISizePart / this._scale;
+        return this._layoutSize;
+    }
+    get UISizePart() {
+        return this._UISizePart;
+    }
+    set UISizePart(value) {
+        this._UISizePart = value;
+        this.onSizeChanged();
+    }
+    get LayoutSizePart() {
+        return this._layoutSizePart;
+    }
+    set LayoutSizePart(value) {
+        this._layoutSizePart = value;
+        this.onSizeChanged();
+    }
+    onSizeChanged() {
+        this._UISize = null;
+        this._layoutSize = null;
+    }
+    addUISize(value) {
+        this.UISizePart += value;
+        return this;
+    }
+    addLayoutSize(value) {
+        this.LayoutSizePart += value;
+        return this;
+    }
+    addSize(value) {
+        this.checkSizeHasSameScale(value);
+        this.addLayoutSize(value._layoutSizePart);
+        this.addUISize(value._UISizePart);
+        return this;
+    }
+    subtractUISize(value) {
+        this.UISizePart -= value;
+        return this;
+    }
+    subtractLayoutSize(value) {
+        this.LayoutSizePart -= value;
+        return this;
+    }
+    subtractSize(value) {
+        this.checkSizeHasSameScale(value);
+        this.subtractLayoutSize(value._layoutSizePart);
+        this.subtractUISize(value._UISizePart);
+        return this;
+    }
+    checkSizeHasSameScale(size) {
+        if (size._scaleIsSpecified && size._scale !== this._scale)
+            throw new Error("The size has a different scale and cannot be added.");
+    }
+    checkScaleIsSpecified() {
+        if (!this._scaleIsSpecified)
+            console.warn("MixedSize is used without specifying the scale.");
+    }
+    useScale(value) {
+        this._scale = value;
+        this._scaleIsSpecified = true;
+        return this;
+    }
+    clear() {
+        this.UISizePart = 0;
+        this.LayoutSizePart = 0;
+        return this;
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/common/layout/document-layout.ts
 
 
+
+
 class ModelPositionHolder {
     constructor(pos, posManager) {
         this.pos = posManager.registerPosition(pos);
@@ -70673,6 +70910,12 @@ class AnchorObjectsPositionInfo {
     }
 }
 class DocumentLayout {
+    get grids() {
+        return this.pages.reduce((res, page) => {
+            page.grids.forEach((grid, table) => res.set(table, grid));
+            return res;
+        }, new Map());
+    }
     constructor(anchorObjectsPositionInfo) {
         this.anchorObjectsPositionInfo = anchorObjectsPositionInfo;
         this.setEmptyLayout(ColorHelper.NO_COLOR);
@@ -70694,6 +70937,11 @@ class DocumentLayout {
     getPageBySubDocumentId(subDocumentId) {
         return this.pages.find((page) => !!page.mainSubDocumentPageAreas[subDocumentId] || !!page.otherPageAreas[subDocumentId]);
     }
+    findPageIndexByOffsetY(offsetY, sizeInfo) {
+        const getPageOffsetY = (p) => MixedSize.fromLayout(sizeInfo.getPageOffsetY(p)).useScale(sizeInfo.zoomLevel).UISize;
+        const normedInterpolationIndex = search.SearchUtils.normedInterpolationIndexOf(this.pages, getPageOffsetY, offsetY);
+        return Math.max(0, normedInterpolationIndex);
+    }
 }
 
 ;// CONCATENATED MODULE: ./src/client/model-api/table/enums.ts
@@ -81673,10 +81921,12 @@ class ParagraphSpacingDestination extends ParagraphFormattingLeafElementDestinat
             const spacingBefore = this.data.readerHelper.getWpSTIntegerValue(reader, 'before', constants.Constants.MIN_SAFE_INTEGER);
             if (spacingBefore >= 0)
                 this.paragraphProperties.setValue(ParagraphPropertyDescriptor.spacingBefore, spacingBefore);
-            this.paragraphProperties.setValue(ParagraphPropertyDescriptor.beforeAutoSpacing, spacingBefore == -1 ||
-                this.data.readerHelper.getWpSTOnOffValue(reader, new WordProcessingMLValue('beforeAutospacing', 'before-autospacing').openXmlValue, false));
-            this.paragraphProperties.setValue(ParagraphPropertyDescriptor.afterAutoSpacing, spacingAfter == -1 ||
-                this.data.readerHelper.getWpSTOnOffValue(reader, new WordProcessingMLValue('afterAutospacing', 'after-autospacing').openXmlValue, false));
+            const beforeAutoSpacing = this.data.readerHelper.getWpSTOnOffValue(reader, 'beforeAutospacing', null);
+            if (spacingBefore == -1 || beforeAutoSpacing != null)
+                this.paragraphProperties.setValue(ParagraphPropertyDescriptor.beforeAutoSpacing, spacingBefore == -1 || beforeAutoSpacing);
+            const afterAutoSpacing = this.data.readerHelper.getWpSTOnOffValue(reader, 'afterAutospacing', null);
+            if (spacingAfter == -1 || afterAutoSpacing != null)
+                this.paragraphProperties.setValue(ParagraphPropertyDescriptor.afterAutoSpacing, spacingAfter == -1 || afterAutoSpacing);
             const lineSpacing = this.data.readerHelper.getWpSTIntegerValue(reader, 'line', constants.Constants.MIN_SAFE_INTEGER);
             if (lineSpacing != constants.Constants.MIN_SAFE_INTEGER && lineSpacing > 0) {
                 const attribute = new WordProcessingMLValue('lineRule', 'line-rule');
@@ -84710,7 +84960,7 @@ class ImagesApi {
             applyVerticalPosition(verticalPosition, anchorInfo);
         const anchorPictureInfo = new AnchorPictureInfo(new PictureSize(true, 0, cacheInfo, new geometry_size.Size(100, 100)), shape, anchorInfo, new NonVisualDrawingObjectInfo(), new NonVisualDrawingObjectInfo());
         anchorPictureInfo.containerProperties.description = options.description;
-        this._processor.modelManager.modelManipulator.picture.insertAnchoredPictureViaHistory(new SubDocumentPosition(this._subDocument, position), inputPos.charPropsBundle, anchorPictureInfo, new ImageLoadingOptions(false, size ? new geometry_size.Size(size.width, size.height) : undefined, (_picInterval, _cacheInfo) => setTimeout(() => {
+        this._processor.modelManager.modelManipulator.picture.insertAnchoredPictureViaHistory(new SubDocumentPosition(this._subDocument, position), inputPos.charPropsBundle, anchorPictureInfo, ImageLoadingOptions.initByActualSize(size ? new geometry_size.Size(size.width, size.height) : undefined, (_picInterval, _cacheInfo) => setTimeout(() => {
             callback(getFloatingImageApiFromRun(this._processor, this._subDocument, this._subDocument.getRunAndIndexesByPosition(position)));
         }, 0)));
         this._processor.endUpdate();
@@ -85288,7 +85538,7 @@ class SubDocumentApi {
     }
     getRtf(interval) {
         const coreInterval = this._checkInterval(interval);
-        return getRtfFromSubDocumentPublic(this._processor.modelManager.richOptions, this._subDocument, coreInterval);
+        return getRtfFromSubDocumentPublic(this._processor, this._subDocument, coreInterval);
     }
     insertContent(position, content, documentFormat, callback) {
         position = ApiParametersChecker.check(position, 1, false, [
@@ -85740,6 +85990,191 @@ class sub_documents_collection_SubDocumentCollection extends Collection {
     }
 }
 
+;// CONCATENATED MODULE: ./src/common/model/fonts/google-fonts.ts
+
+
+
+
+
+class GoogleFontsApi {
+    constructor(controlFontsCache, fonts) {
+        this.fontFamilyToFontInfo = {};
+        this.fonts = fonts;
+        this.controlFontsCache = controlFontsCache;
+        const params = this.fonts.map(font => {
+            const fontFamily = font.getFontFamilies()[0];
+            this.fontFamilyToFontInfo[fontFamily] = font;
+            return `${fontFamily.replace(' ', '+')}:regular,bold,italic,bolditalic`;
+        }).join('|');
+        this.uri = `https://fonts.googleapis.com/css?family=${params}`;
+    }
+    loadControlFonts(callback) {
+        const notLoaded = () => callback([]);
+        const xhr = new XMLHttpRequest();
+        xhr.onload = (_e) => {
+            const responce = xhr.response;
+            if (xhr.status >= 400 || !responce)
+                notLoaded();
+            else
+                callback(this.parseResponce(responce));
+        };
+        xhr.onerror = () => notLoaded();
+        xhr.open("GET", this.uri, true);
+        xhr.responseType = "text";
+        xhr.send();
+    }
+    parseResponce(responce) {
+        const result = [];
+        let regexpResult;
+        const regexp = /@font-face\s*\{([\s\S]*?)\}/gm;
+        while (regexpResult = regexp.exec(responce)) {
+            const fontInfo = regexpResult[1];
+            const fontFamily = fontInfo.match(/font-family:\s*'(\w+\s*\w*)';/);
+            if (fontFamily && fontFamily[1]) {
+                const url = GoogleFontsApi.parseSrc(fontInfo.match(/src:\s*(.+);/));
+                const fontStyle = fontInfo.match(/font-style:\s*(\w+);/);
+                const fontWeight = fontInfo.match(/font-weight:\s*(.+);/);
+                const unicodeRange = fontInfo.match(/unicode-range:\s*(.+);/);
+                const desc = new FontFaceDescriptors();
+                if (fontStyle && fontStyle[1])
+                    desc.style = fontStyle[1];
+                if (fontWeight && fontWeight[1])
+                    desc.weight = fontWeight[1];
+                if (unicodeRange && unicodeRange[1])
+                    desc.unicodeRange = unicodeRange[1];
+                const controlFont = this.controlFontsCache.addFont(new ControlFont(fontFamily[1], desc));
+                if (url && utils_list.ListUtils.allOf(controlFont.sourceUrls, s => s != url)) {
+                    controlFont.sourceUrls.unshift(url);
+                    const fontInfo = this.fontFamilyToFontInfo[controlFont.fontFamily];
+                    const controlFontType = new class_flag.Flag();
+                    controlFontType.set(ControlFontType.Bold, controlFont.descriptors.msWordBold());
+                    controlFontType.set(ControlFontType.Italic, controlFont.descriptors.msWordItalic());
+                    fontInfo.controlFontMap[controlFontType.getValue()] = controlFont.cacheKey;
+                    result.push(controlFont);
+                }
+            }
+        }
+        return result;
+    }
+    static parseSrc(matchSrc) {
+        if (matchSrc && matchSrc[1])
+            for (let src of matchSrc[1].split(',')) {
+                const matchUrl = src.match(/url\((.+)\)\s*format\('(\w+)'\)/);
+                if (matchUrl)
+                    return matchUrl[1];
+            }
+        return null;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/common/model/creator/cache.ts
+
+
+class ModelCacheFiller {
+    constructor(model, fontsSettings) {
+        this.model = model;
+        this.fontsSettings = fontsSettings;
+    }
+    fillCache() {
+        this.makeFontMap();
+        this.replaceCharProperties(this.model, "defaultCharacterProperties");
+        this.model.characterStyles.forEach(style => this.replaceCharProperties(style, "maskedCharacterProperties"));
+        this.model.paragraphStyles.forEach(style => this.replaceCharProperties(style, "maskedCharacterProperties"));
+        this.model.tableStyles.forEach(style => {
+            this.replaceCharProperties(style.baseConditionalStyle, 'maskedCharacterProperties');
+            number/* NumberMapUtils */.j.forEach(style.conditionalStyles, style => this.replaceCharProperties(style, 'maskedCharacterProperties'));
+        });
+        number/* NumberMapUtils */.j.forEach(this.model.subDocuments, sd => this.replaceInModelSubDocument(sd));
+    }
+    makeFontMap() {
+        const fontInfoCache = this.model.cache.fontInfoCache;
+        const fontsSettings = this.fontsSettings;
+        this.fontMap = Object.create(null);
+        fontInfoCache.getAllFonts().forEach(font => this.fontMap[font.name] = fontsSettings.getPermittedFont(fontInfoCache, font));
+    }
+    replaceCharProperties(object, propKey) {
+        const props = object[propKey];
+        props.fontInfo = props.fontInfo ? this.fontMap[props.fontInfo.name] : this.model.defaultCharacterProperties.fontInfo;
+        if (props instanceof MaskedCharacterProperties)
+            object[propKey] = this.model.cache.maskedCharacterPropertiesCache.getItem(props);
+        else
+            object[propKey] = this.model.cache.mergedCharacterPropertiesCache.getItem(props);
+    }
+    replaceInModelSubDocument(sd) {
+        sd.paragraphs.forEach(p => p.resetParagraphMergedProperties());
+        sd.chunks.forEach(chunk => {
+            chunk.textRuns.forEach(run => {
+                this.replaceCharProperties(run, 'maskedCharacterProperties');
+                run.resetCharacterMergedProperties();
+            });
+        });
+    }
+}
+
+;// CONCATENATED MODULE: ./src/common/model/creator/font-corrector.ts
+
+
+
+
+
+
+
+class FontCorrector {
+    get fontInfoCache() {
+        return this.model.cache.fontInfoCache;
+    }
+    get controlFontsCache() {
+        return this.model.cache.controlFontsCache;
+    }
+    constructor(modelManipulator, model, fonts) {
+        this.modelManipulator = modelManipulator;
+        this.model = model;
+        this.fonts = fonts;
+    }
+    correct() {
+        this.addAndLoad();
+        new ModelCacheFiller(this.model, this.fonts).fillCache();
+        this.removeRedundant();
+        this.modelManipulator.raiseFontListChanged(this.fontInfoCache);
+    }
+    addAndLoad() {
+        this.fonts.fonts.forEach(font => {
+            let newFont = this.fontInfoCache.getItemByName(font.name);
+            if (!newFont)
+                newFont = this.fontInfoCache.addFont(font.name, font.fontFamily);
+            else
+                newFont.cssString = FontInfoCache.correctCssString(font.fontFamily);
+            const addControlFont = (uri, desc) => {
+                const controlFont = this.controlFontsCache.addFont(new ControlFont(font.fontFamily, desc));
+                controlFont.sourceUrls.unshift(uri);
+                const controlFontType = new class_flag.Flag();
+                controlFontType.set(ControlFontType.Bold, controlFont.descriptors.msWordBold());
+                controlFontType.set(ControlFontType.Italic, controlFont.descriptors.msWordItalic());
+                newFont.controlFontMap[controlFontType.getValue()] = controlFont.cacheKey;
+            };
+            if (font.regularFontUri)
+                addControlFont(font.regularFontUri, FontFaceDescriptors.create({}));
+            if (font.boldFontUri)
+                addControlFont(font.boldFontUri, FontFaceDescriptors.create({ weight: 'bold' }));
+            if (font.italicFontUri)
+                addControlFont(font.italicFontUri, FontFaceDescriptors.create({ style: 'italic' }));
+            if (font.boldItalicFontUri)
+                addControlFont(font.boldItalicFontUri, FontFaceDescriptors.create({ weight: 'bold', style: 'italic' }));
+            if (font.googleFontsResponse)
+                new GoogleFontsApi(this.controlFontsCache, [newFont]).parseResponce(font.googleFontsResponse);
+            else if (font.useGoogleFonts)
+                new GoogleFontsApi(this.controlFontsCache, [newFont]).loadControlFonts(_createdFonts => { });
+        });
+    }
+    removeRedundant() {
+        if (this.fonts.limitedFonts) {
+            const map = {};
+            this.fonts.fonts.forEach(f => map[f.name] = f);
+            this.fontInfoCache.removeItems(font => !map[font.name]);
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/client/model-api/document.ts
 
 
@@ -85750,6 +86185,7 @@ class sub_documents_collection_SubDocumentCollection extends Collection {
 
 
 
+
 class RichEditDocumentApi {
     constructor(processor) {
         this._processor = processor;
@@ -85848,6 +86284,7 @@ class RichEditDocumentApi {
         this._processor.modelManager.model.defaultCharacterProperties =
             this._processor.modelManager.model.cache.maskedCharacterPropertiesCache.getItem(propertiesCore);
         number/* NumberMapUtils */.j.forEach(this._processor.modelManager.model.subDocuments, (sd) => sd.resetMergedFormattingCache(ResetFormattingCacheType.All));
+        new FontCorrector(this._processor.modelManager.modelManipulator, this._processor.modelManager.model, this._processor.modelManager.richOptions.fonts).correct();
         this._processor.layoutFormatterManager.restartManager.restartAllLayout();
         this._processor.endUpdate();
     }
@@ -86278,7 +86715,6 @@ var RichEditClientCommand;
     RichEditClientCommand[RichEditClientCommand["GetHtml"] = 458] = "GetHtml";
     RichEditClientCommand[RichEditClientCommand["CreateEmptyIfField"] = 459] = "CreateEmptyIfField";
     RichEditClientCommand[RichEditClientCommand["ChangeZoomLevel"] = 460] = "ChangeZoomLevel";
-    RichEditClientCommand[RichEditClientCommand["ToggleAllowZoom"] = 461] = "ToggleAllowZoom";
 })(RichEditClientCommand || (RichEditClientCommand = {}));
 
 ;// CONCATENATED MODULE: ./src/common/interfaces/i-rich-edit-core.ts
@@ -88718,21 +89154,13 @@ class SectionExporter extends BaseExporter {
         this.exportSectionGeneralSettings(props);
     }
     exportSectionPage(props) {
-        if (!this.shouldExportSectionPage(props))
-            return;
         this.writer.writeWpStartElement('pgSz');
-        if (props.pageSize.width != SectionExporter.defaultProps.pageSize.width)
-            this.writer.writeWpIntAttr('w', props.pageSize.width);
-        if (props.pageSize.height != SectionExporter.defaultProps.pageSize.height)
-            this.writer.writeWpIntAttr('h', props.pageSize.height);
+        this.writer.writeWpIntAttr('w', props.pageSize.width);
+        this.writer.writeWpIntAttr('h', props.pageSize.height);
         if (props.landscape)
             this.writer.writeWpStringAttr('orient', props.landscape ? 'landscape' : 'portrait');
         this.writer.endElement();
     }
-    shouldExportSectionPage(props) {
-        return !props.pageSize.equals(SectionExporter.defaultProps.pageSize) ||
-            props.landscape != SectionExporter.defaultProps.landscape;
-    }
     exportSectionMargins(props) {
         this.writer.writeWpStartElement('pgMar');
         this.writer.writeWpIntAttr('left', props.marginLeft);
@@ -90519,6 +90947,7 @@ class EffectExtent {
 
 
 
+
 class TableExporter extends BaseExporter {
     constructor() {
         super(...arguments);
@@ -90548,10 +90977,9 @@ class TableExporter extends BaseExporter {
         }
     }
     getTableGrid(table) {
-        if (table.rows[0].logicColumnCount < 64)
-            return [];
-        const colGrid = [];
-        return colGrid;
+        var _a, _b;
+        const grid = this.data.grids.get(table);
+        return ((_b = (_a = grid === null || grid === void 0 ? void 0 : grid.columns) === null || _a === void 0 ? void 0 : _a.width) === null || _b === void 0 ? void 0 : _b.map(unit_converter/* UnitConverter */.u.pixelsToTwips)) || [];
     }
     initNewTables(newIndexes, allowInitNextTable) {
         for (let levelIndex = this.tableIndexes.length; levelIndex < newIndexes.length; levelIndex++) {
@@ -91061,11 +91489,12 @@ class data_Data {
     get subDocumentExporter() { return this.subDocumentExporterStack.last; }
     get relationExporter() { return utils_list.ListUtils.last(this.relationExporters); }
     get mainSubDocumentRelations() { return this.relationExporters[0]; }
-    constructor(model, options) {
+    constructor(exportModelOptions, options) {
         this.drawingElementId = 1;
         this.exportSubDocumentsList = [];
         this.relationExporters = [];
-        this.model = model;
+        this.model = exportModelOptions.modelManager.model;
+        this.grids = exportModelOptions.grids;
         this.options = options;
         this.constants = new DocxConstants();
         this.writerStack = new stack/* Stack */.K();
@@ -91849,10 +92278,10 @@ class EndNoteExporter extends NoteExporter {
 
 
 class DocxExporter {
-    constructor(modelManipulator, options) {
-        this.modelManipulator = modelManipulator;
+    constructor(exportModelOptions, options) {
+        this.modelManipulator = exportModelOptions.modelManager.modelManipulator;
         this.options = options;
-        this.data = new data_Data(modelManipulator.model, options);
+        this.data = new data_Data(exportModelOptions, options);
     }
     exportToBlob(callback) {
         this.modelManipulator.picture.loader.ensureAllPicturesLoaded(this.options.ensurePictureLoadedTimeout, (_loaded) => {
@@ -91959,8 +92388,8 @@ function exportModelToBlob(exportModelOptions, callback) {
 function getExporter(exportModelOptions) {
     const { modelManipulator } = exportModelOptions.modelManager;
     switch (exportModelOptions.documentFormat) {
-        case DocumentFormat.OpenXml: return new DocxExporter(modelManipulator, new DocxExportOptions());
-        case DocumentFormat.Rtf: return new RtfExporter(modelManipulator, new RtfDocumentExporterOptions());
+        case DocumentFormat.OpenXml: return new DocxExporter(exportModelOptions, new DocxExportOptions());
+        case DocumentFormat.Rtf: return new RtfExporter(exportModelOptions, new RtfDocumentExporterOptions());
         case DocumentFormat.PlainText: return new TxtExporter(modelManipulator, new DocumentExporterOptions());
         case DocumentFormat.Html: return new HtmlDocumentExporter(exportModelOptions, new DocumentExporterOptions());
         default:
@@ -92471,7 +92900,7 @@ class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositionCalcu
     alignment(type, alignment) {
         switch (type) {
             case AnchorObjectHorizontalPositionType.Character:
-                return this.getAlignPosition(alignment, 0);
+                return this.getAnchorXPosition() + this.getAlignPosition(alignment, 0);
             case AnchorObjectHorizontalPositionType.Column:
                 return this.isRelativeCell ?
                     this.relativeColumnPos() + this.lp.row.tableCellInfo.x +
@@ -92520,17 +92949,8 @@ class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositionCalcu
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x : 0;
             case AnchorObjectHorizontalPositionType.Column:
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x + this.leftCellMargin : this.relativeColumnPos();
-            case AnchorObjectHorizontalPositionType.Character: {
-                const rowAbsPos = this.lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
-                const ancBoxAbsPos = this.obj.rowOffset;
-                const boxIndex = search.SearchUtils.normedInterpolationIndexOf(this.lp.row.boxes, (box) => rowAbsPos + box.rowOffset, ancBoxAbsPos);
-                const box = this.lp.row.boxes[boxIndex];
-                if (!box)
-                    return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row);
-                const symbolCount = Math.max(0, ancBoxAbsPos - rowAbsPos - box.rowOffset);
-                return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row) + box.x +
-                    box.getCharOffsetXInPixels(this.manager.measurer, symbolCount);
-            }
+            case AnchorObjectHorizontalPositionType.Character:
+                return this.getAnchorXPosition();
             case AnchorObjectHorizontalPositionType.Margin:
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x + this.leftCellMargin :
                     this.manager.boundsCalculator.marginLeft;
@@ -92547,6 +92967,19 @@ class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositionCalcu
                 throw new Error(lib_errors/* Errors */.D.InternalException);
         }
     }
+    getAnchorXPosition() {
+        const rowAbsPos = this.lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
+        const ancBoxAbsPos = this.obj.rowOffset;
+        let boxIndex = search.SearchUtils.normedInterpolationIndexOf(this.lp.row.boxes, (box) => rowAbsPos + box.rowOffset, ancBoxAbsPos);
+        if (boxIndex < 0)
+            boxIndex = 0;
+        const box = this.lp.row.boxes[boxIndex];
+        if (!box)
+            return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row);
+        const symbolCount = Math.max(0, ancBoxAbsPos - rowAbsPos - box.rowOffset);
+        return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row) + box.x +
+            box.getCharOffsetXInPixels(this.manager.measurer, symbolCount);
+    }
     bookLayout() {
         return this.alignment(this.anchorInfo.horizontalPositionType, AnchorObjectHorizontalPositionCalculator.mapBookLayoutALignmentType[this.anchorInfo.horizontalPositionAlignment]);
     }
@@ -92772,6 +93205,12 @@ class AnchoredTextBoxContextSizeCalculator {
 
 
 class LayoutPageArea extends rectangle.Rectangle {
+    get grids() {
+        return this.columns.reduce((res, column) => {
+            column.tablesInfo.forEach(tableInfo => res.set(tableInfo.logicInfo.grid.table, tableInfo.logicInfo.grid));
+            return res;
+        }, new Map());
+    }
     constructor(subDocument) {
         super(0, 0, 0, 0);
         this.columns = [];
@@ -92797,7 +93236,6 @@ class LayoutPageArea extends rectangle.Rectangle {
 
 
 
-
 var LayoutRowStateFlags;
 (function (LayoutRowStateFlags) {
     LayoutRowStateFlags[LayoutRowStateFlags["NormallyEnd"] = 0] = "NormallyEnd";
@@ -92924,7 +93362,7 @@ class layout_row_LayoutRow extends rectangle.Rectangle {
         return lastBoxIndexWhatCanStrikeoutAndUnderline;
     }
     containsSpacesOnly() {
-        return this.boxes.length > 0 && utils_list.ListUtils.allOf(this.boxes, val => val.isWhitespace() || val.getType() === LayoutBoxType.ParagraphMark);
+        return this.boxes.length > 0 && utils_list.ListUtils.allOf(this.boxes, val => val.isWhitespace());
     }
 }
 class LayoutRowWithIndex extends (/* unused pure expression or super */ null && (layout_row_LayoutRow)) {
@@ -95019,10 +95457,10 @@ class RowFormattingInfo {
         const ind = utils_list.ListUtils.indexBy(this.intervals, (curr) => curr.start > pos || pos < curr.end, this.currIndex + 1);
         return ind < 0 ? this.intervals.length - 1 : ind;
     }
-    calculate() {
+    calculate(outerHorizontalRowContentBounds) {
         this.setIntersectObjects();
         this.busyIntervals = algorithms.IntervalAlgorithms.getMergedIntervals(utils_list.ListUtils.map(this.intersectsObjects, (objBnds) => new fixed.FixedInterval(objBnds.x, objBnds.width)), true);
-        const freeIntervals = algorithms.IntervalAlgorithms.reflectIntervals(this.busyIntervals, this.outerHorizontalRowContentBounds);
+        const freeIntervals = this.calculateFreeIntervals(this.busyIntervals, outerHorizontalRowContentBounds !== null && outerHorizontalRowContentBounds !== void 0 ? outerHorizontalRowContentBounds : this.outerHorizontalRowContentBounds);
         if (freeIntervals.length) {
             this.intervals = utils_list.ListUtils.map(freeIntervals, (curr) => new RowIntervalInfo(curr.start, curr.length));
             return;
@@ -95030,6 +95468,40 @@ class RowFormattingInfo {
         this.resetMinY(utils_list.ListUtils.min);
         Log.print(LogSource.RowFormatter, "RowFormattingInfo.calculate ", `minY:${this.minY}, height:${this.height}, currIndex: ${this.currIndex} intervals:\n${Log.join("\n", utils_list.ListUtils.map(this.intervals, (curr) => LogObjToStr.fixedInterval(curr)))}`);
     }
+    calculateFreeIntervals(busyIntervals, outerHorizontalRowContentBounds) {
+        const intervals = utils_list.ListUtils.reducedMap(busyIntervals, val => algorithms.IntervalAlgorithms.getIntersectionNonNullLength(val, outerHorizontalRowContentBounds));
+        if (!intervals.length)
+            return [outerHorizontalRowContentBounds.clone()];
+        const lastIntervalEnd = utils_list.ListUtils.last(intervals).end;
+        const result = utils_list.ListUtils.reducedMap(intervals, (curr, i) => fixed.FixedInterval.fromPositions(busyIntervals[i - 1].end, curr.start), 1);
+        if (outerHorizontalRowContentBounds.start < busyIntervals[0].start)
+            result.unshift(fixed.FixedInterval.fromPositions(outerHorizontalRowContentBounds.start, busyIntervals[0].start));
+        if (outerHorizontalRowContentBounds.end > lastIntervalEnd)
+            result.push(fixed.FixedInterval.fromPositions(lastIntervalEnd, outerHorizontalRowContentBounds.end));
+        return result;
+    }
+    recalculate(outerHorizontalRowContentBounds) {
+        const currInterval = this.currInterval;
+        this.calculate(outerHorizontalRowContentBounds);
+        const pos = currInterval.start + currInterval.busyWidth;
+        const index = this.findIntervalIndexByPosition(pos);
+        const interval = this.intervals[index];
+        if (interval && interval.start < pos) {
+            const avaliableWidth = interval.length - (pos - interval.start);
+            interval.avaliableWidth = avaliableWidth;
+        }
+        this.currIndex = index;
+    }
+    findIntervalIndexByPosition(position) {
+        let index = 0;
+        while (index < this.intervals.length) {
+            const interval = this.intervals[index];
+            if (interval.start <= position && position < interval.end || position < interval.start)
+                break;
+            index++;
+        }
+        return index;
+    }
     canIncrementHeightTo(newHeight) {
         const contentBounds = utils_list.ListUtils.map(this.intervals, (c) => new rectangle.Rectangle(c.start, this.minY, c.busyWidth, newHeight));
         const intersectedObjects = this.calcIntersectObjects(newHeight);
@@ -95620,8 +96092,6 @@ class RowBaseFormatterState {
             this.rowFormatter.finishRow();
     }
     addAnchorObject() {
-        if (!this.rowFormatter.wordHolder.pushBoxes())
-            return;
         this.rowFormatter.addAnchorObject();
     }
     addTextBox() {
@@ -95753,7 +96223,7 @@ class RowTabInfo {
             const tab = this.tabPositions[ind];
             const oldTabPos = tab ? tab.position : Number.MAX_VALUE;
             if (oldTabPos != pos)
-                this.tabPositions.splice(pos > oldTabPos ? ind + 1 : ind, 0, new TabInfo(pos, TabAlign.Left, TabLeaderType.None, false, false));
+                this.tabPositions.splice(pos > oldTabPos ? ind + 1 : ind, 0, new TabInfo(pos, TabAlign.Left, TabLeaderType.None, false, false, true));
         }
         for (let pos of this.tabPositions)
             pos.position += this.paragraphHorizontalBoundsStart;
@@ -95799,9 +96269,10 @@ class RowTabInfo {
         const lastInterval = utils_list.ListUtils.last(this.rowFormatter.rowSizesManager.rowFormattingInfo.intervals);
         if (tabXPosRelativePage > lastInterval.end) {
             if (lastInterval.end < this.rowFormatter.paragraphHorizontalBounds.end) {
-                if (this.rowFormatter.manager.model.compatibilitySettings.compatibilityMode < CompatibilityMode.Word2013) {
-                    this.currInterval.avaliableWidth = Number.MAX_SAFE_INTEGER - this.currInterval.busyWidth;
-                    this.currInterval.length = Number.MAX_SAFE_INTEGER;
+                if (this.rowFormatter.manager.model.compatibilitySettings.compatibilityMode < CompatibilityMode.Word2013 && tabPosition && !tabPosition.isParagraphIndent) {
+                    const interval = this.rowFormatter.rowSizesManager.rowFormattingInfo.outerHorizontalRowContentBounds;
+                    interval.length = Number.MAX_SAFE_INTEGER - interval.start;
+                    this.rowFormatter.rowSizesManager.rowFormattingInfo.recalculate(interval);
                     this.row.width = Number.MAX_SAFE_INTEGER;
                     this.row.flags.set(LayoutRowStateFlags.InfinityWidth, true);
                     return this.addTabBox();
@@ -95917,7 +96388,7 @@ class WordHolderInfo {
         }
         if (res == null)
             return false;
-        if (this.rowFormatter.row.isEmpty()) {
+        if (this.rowFormatter.row.isEmpty() || this.rowFormatter.row.containsSpacesOnly()) {
             if (this.rowFormatter.rowSizesManager.rowFormattingInfo.isFloatingIntersectRow) {
                 this.rowFormatter.rowSizesManager.rowFormattingInfo.findNextYPosWhatHasNeededSpace(res.requiredWidth);
                 return this.pushBoxes();
@@ -98163,25 +98634,9 @@ class table_info_TableInfo {
             tableIndent.value = 0;
         }
         const tableIndentInPixels = tableIndent.asNumberNoPercentType(unit_converter/* UnitConverter */.u.twipsToPixels);
-        this.xPositionStart = xPosition + tableIndentInPixels + (diff.xDiff ? diff.xDiff : -firstCellLeftMargin) +
-            this.getShiftHorizontalPosition(xPosition);
+        this.xPositionStart = xPosition + tableIndentInPixels + (diff.xDiff ? diff.xDiff : -firstCellLeftMargin);
         this.yPositionStart = yOffset + diff.yDiff;
     }
-    getShiftHorizontalPosition(xPosition) {
-        const freeSpaceFromTable = this.columnWidth - this.grid.commonWidth;
-        if (freeSpaceFromTable >= 0)
-            return 0;
-        const tableAlignment = this.table.getActualTableAlignment();
-        if (tableAlignment == TableRowAlignment.Center) {
-            let result = freeSpaceFromTable / 2 - xPosition;
-            if (result < 0 && this.isSimpleView)
-                result = 0;
-            return result;
-        }
-        else if (tableAlignment == TableRowAlignment.Right)
-            return freeSpaceFromTable - xPosition;
-        return 0;
-    }
     static getEstimatedTableWidth(table, maxWidth) {
         const preferredWidth = table.preferredWidth;
         const minWidth = 3 * table.rows[0].getTotalCellsInRowConsiderGrid();
@@ -98264,6 +98719,12 @@ class LayoutTableSizeCompressor {
             LayoutTableSizeCompressor.cellCompress(cell, cell.createRectangle());
     }
     static tableCompress(tableInfo, boundsRelativeColumn) {
+        const intersection = rectangle.Rectangle.getIntersection(tableInfo, boundsRelativeColumn);
+        const headOffset = intersection.x - tableInfo.x;
+        if (headOffset > 0) {
+            tableInfo.verticalBorders.forEach(b => b.xPos -= headOffset);
+            tableInfo.verticalCursorBorders.forEach(b => b.xPos -= headOffset);
+        }
         LayoutTableSizeCompressor.compress(tableInfo, boundsRelativeColumn, true, false);
         const boundsRelativeTable = tableInfo.clone().moveRectangle(-tableInfo.x, -tableInfo.y);
         for (let row of tableInfo.tableRows)
@@ -98332,8 +98793,9 @@ class LayoutTableSizeCompressor {
         }
         border.length = Math.min(border.yPos + border.length, bounds.bottom) - border.yPos;
         if (border.xPos < bounds.x)
-            return true;
-        border.xPos = bounds.right;
+            border.xPos = bounds.x;
+        else
+            border.xPos = bounds.right;
         border.borderInfo.width = 0;
         return false;
     }
@@ -103492,6 +103954,7 @@ class CanvasUtils {
 
 
 
+
 
 
 class SimpleViewCanvasSizeManager {
@@ -103518,6 +103981,10 @@ class SimpleViewCanvasSizeManager {
         this.resizeFrameId = null;
         this.resizeObserver.disconnect();
     }
+    modelChanged(change) {
+        if (change.type == ModelChangeType.ZoomLevelChanged && this.control.innerClientProperties.viewsSettings.isSimpleView)
+            this.changeSize(true);
+    }
     changeSize(force) {
         const curr = new geometry_size.Size(this.canvasManager.getCanvasWidth(), this.canvasManager.controlHeightProvider.getVisibleAreaHeight(false));
         if (force || !curr.equals(this.size)) {
@@ -103543,18 +104010,16 @@ class SimpleViewCanvasSizeManager {
         this.sizeUpdated = true;
     }
     changeSizeCore() {
-        {
-            utils_list.ListUtils.forEach(this.control.viewManager.cache, (_val) => this.control.viewManager.renderer.removePage(1), 1);
-            this.control.viewManager.ensureFirstPageIsRendered();
-            this.control.innerClientProperties.viewsSettings.widthOfPage = this.canvasManager.getCanvasWidth();
-            if (this.control.layoutFormatterManager) {
-                this.control.layoutFormatterManager.invalidator.onChangedAllLayout();
-                this.control.selection.scrollManager.setScroll(new ScrollState().byModelPosition(this.control.selection)
-                    .setModelPosition(this.control.selection.lastSelectedInterval.start).useStdRelativePosition().useStdOffset());
-            }
-            this.control.owner.adjustControl();
-            this.control.horizontalRulerControl.update();
+        utils_list.ListUtils.forEach(this.control.viewManager.cache, (_val) => this.control.viewManager.renderer.removePage(1), 1);
+        this.control.viewManager.ensureFirstPageIsRendered();
+        this.control.innerClientProperties.viewsSettings.widthOfPage = this.canvasManager.getCanvasWidth();
+        if (this.control.layoutFormatterManager) {
+            this.control.layoutFormatterManager.invalidator.onChangedAllLayout();
+            this.control.selection.scrollManager.setScroll(new ScrollState().byModelPosition(this.control.selection)
+                .setModelPosition(this.control.selection.lastSelectedInterval.start).useStdRelativePosition().useStdOffset());
         }
+        this.control.owner.adjustControl();
+        this.control.horizontalRulerControl.update();
     }
 }
 class DocumentRenderer {
@@ -103738,7 +104203,7 @@ class DocumentRenderer {
         }
     }
     updatePageSize(page, pageElement) {
-        if (pageElement.offsetHeight != page.height || pageElement.offsetWidth != page.width)
+        if (pageElement.offsetHeight != Math.round(page.height) || pageElement.offsetWidth != Math.round(page.width))
             dom.DomUtils.setStyleSize(pageElement.style, page);
     }
     updatePageClasses(pageElement) {
@@ -106437,40 +106902,31 @@ class MouseHandlerDefaultState extends MouseHandlerStateBase {
         this.processMouseDownOnMaxDetailsLevel(evt, htr, activeSubDocument);
     }
     processMouseDownOnMaxDetailsLevel(evt, htr, activeSubDocument) {
+        const selection = this.handler.control.selection;
         if (htr.floatingObject) {
-            if (htr.floatingObject.belongsToSubDocId != this.handler.control.selection.activeSubDocument.id)
-                MouseHandlerHelper.changeActiveSubDocumentToParent(this.handler.control);
             const box = htr.floatingObject;
-            this.selectFloatingObject(box);
-            const specRunInfo = this.handler.control.selection.specialRunInfo;
-            if (specRunInfo.isSelectedAnchorObject) {
-                if (box.getType() == LayoutBoxType.AnchorTextBox &&
-                    HitTestManager.isPointInTexBoxArea(evt.layoutPoint, box, activeSubDocument.isTextBox() ? 0 : box.rotationInRadians)) {
+            const rotationAngle = activeSubDocument.isTextBox() ? 0 : box.rotationInRadians;
+            if (box.getType() == LayoutBoxType.AnchorTextBox && HitTestManager.isPointInTexBoxArea(evt.layoutPoint, box, rotationAngle)) {
+                const textbox = box;
+                if (textbox.internalSubDocId !== selection.activeSubDocument.id && this.selectFloatingObject(box)) {
                     this.handler.control.commandManager.getCommand(RichEditClientCommand.ChangeActiveSubDocumentToTextBox).execute(this.handler.control.commandManager.isPublicApiCall);
                     this.handler.boxVisualizerManager.resizeBoxVisualizer.show(htr.pageIndex, null, null, null, box);
-                    htr = this.handler.control.hitTestManager.calculate(evt.layoutPoint, DocumentLayoutDetailsLevel.Max, this.handler.control.selection.activeSubDocument);
-                }
-                else {
-                    if (this.resizeRotationChecker(() => {
-                        const dragFloatingObjectState = new MouseHandlerDragFloatingObjectState(this.handler, evt);
-                        this.handler.switchState(new MouseHandlerBeginDragHelperState(evt.layoutPoint, this.handler, dragFloatingObjectState));
-                    }))
-                        return;
-                    else {
-                        if (specRunInfo.isPictureSelected()) {
-                            this.handler.control.selection.setSelection(new SetSelectionParams()
-                                .setInterval(new fixed.FixedInterval(specRunInfo.getPicturePosition(), 1)));
-                            return;
-                        }
-                    }
+                    htr = this.handler.control.hitTestManager.calculate(evt.layoutPoint, DocumentLayoutDetailsLevel.Max, selection.activeSubDocument);
                 }
             }
+            else {
+                if (this.selectFloatingObject(box) && this.resizeRotationChecker(() => {
+                    const dragFloatingObjectState = new MouseHandlerDragFloatingObjectState(this.handler, evt);
+                    this.handler.switchState(new MouseHandlerBeginDragHelperState(evt.layoutPoint, this.handler, dragFloatingObjectState));
+                }))
+                    return;
+            }
         }
         if (browser.Browser.TouchUI && htr.subDocument.isMain() && htr.exactlyDetailLevel < DocumentLayoutDetailsLevel.PageArea) {
             if (htr.deviations[DocumentLayoutDetailsLevel.PageArea] & rectangle.HitTestDeviation.Top || htr.deviations[DocumentLayoutDetailsLevel.PageArea] & rectangle.HitTestDeviation.Bottom)
                 this.handler.control.viewManager.canvasScrollManager.waitForDblClick();
         }
-        if (evt.button === MouseButton.Right && this.handler.control.selection.lastSelectedInterval.contains(htr.getPosition()))
+        if (evt.button === MouseButton.Right && selection.lastSelectedInterval.contains(htr.getPosition()))
             return;
         if (this.shouldSelectEntireTableColumn(htr))
             this.beginSelectEntireTableColumn(htr, evt);
@@ -106485,7 +106941,7 @@ class MouseHandlerDefaultState extends MouseHandlerStateBase {
                 this.beginSelectEntireTableCell(htr, evt);
         }
         else if (this.isLeftArea(htr, evt)) {
-            if (evt.modifiers & key/* ModifierKey */.tx.Ctrl && this.handler.control.selection.isCollapsed())
+            if (evt.modifiers & key/* ModifierKey */.tx.Ctrl && selection.isCollapsed())
                 this.handler.control.commandManager.getCommand(RichEditClientCommand.SelectAll).execute(this.handler.control.commandManager.isPublicApiCall, htr.getPosition());
             else if (this.isLeftAreaOffset(htr, evt))
                 this.beginLineSelection(htr, evt);
@@ -106693,8 +107149,14 @@ class MouseHandlerDefaultState extends MouseHandlerStateBase {
         this.handler.switchState(state);
     }
     selectFloatingObject(box) {
+        const selection = this.handler.control.selection;
+        if (box.belongsToSubDocId !== selection.activeSubDocument.id)
+            MouseHandlerHelper.changeActiveSubDocumentToParent(this.handler.control);
+        if (box.belongsToSubDocId !== selection.activeSubDocument.id)
+            return false;
         const pos = this.handler.control.layout.anchorObjectsPositionInfo.getPosition(box.objectId);
-        this.handler.control.selection.setSelection(new SetSelectionParams().setInterval(new fixed.FixedInterval(pos, 1)));
+        selection.setSelection(new SetSelectionParams().setInterval(new fixed.FixedInterval(pos, 1)));
+        return selection.specialRunInfo.isSelectedAnchorObject;
     }
 }
 class MouseHandlerHelper {
@@ -107867,31 +108329,56 @@ ResizeBoxListener.directionToSource = {
 };
 
 ;// CONCATENATED MODULE: ./src/common/utils/size-utils.ts
+
 class SizeUtils {
+    static getScrollbarsWidth() {
+        if (!(0,common.isDefined)(this._scrollbarsWidth)) {
+            const scrollDiv = document.createElement('div');
+            scrollDiv.style.visibility = 'hidden';
+            scrollDiv.style.overflow = 'scroll';
+            scrollDiv.style.position = 'absolute';
+            scrollDiv.style.top = '-9999px';
+            scrollDiv.style.width = '100px';
+            scrollDiv.style.height = '100px';
+            document.body.appendChild(scrollDiv);
+            const innerDiv = document.createElement('div');
+            innerDiv.style.width = '100%';
+            innerDiv.style.height = '100%';
+            scrollDiv.appendChild(innerDiv);
+            this._scrollbarsWidth = {
+                horizontal: SizeUtils.getOffsetHeight(scrollDiv) - SizeUtils.getOffsetHeight(innerDiv),
+                vertical: SizeUtils.getOffsetWidth(scrollDiv) - SizeUtils.getOffsetWidth(innerDiv)
+            };
+            scrollDiv.remove();
+        }
+        return this._scrollbarsWidth;
+    }
     static getWidthInfo(element) {
-        const offsetSize = SizeUtils.getOffsetWidth(element);
-        const style = getComputedStyle(element);
-        const inset = parseCssValue(style.borderLeftWidth)
-            + parseCssValue(style.borderRightWidth)
-            + parseCssValue(style.paddingLeft)
-            + parseCssValue(style.paddingRight);
-        const sizeWithScrollBar = offsetSize - inset;
-        const scrollBarSize = Math.round(sizeWithScrollBar) - element.clientWidth;
-        return new DimensionInfo(offsetSize, sizeWithScrollBar - scrollBarSize, scrollBarSize);
+        const computedStyle = getComputedStyle(element);
+        const offsetWidth = this.getOffsetWidth(element);
+        const offsetWidthWithoutBorder = offsetWidth
+            - parseCssValue(computedStyle.borderLeftWidth)
+            - parseCssValue(computedStyle.borderRightWidth);
+        let scrollbarWidth = 0;
+        if (Math.round(offsetWidthWithoutBorder) > element.clientWidth)
+            scrollbarWidth = SizeUtils.getScrollbarsWidth().vertical;
+        const clientWidth = offsetWidthWithoutBorder - scrollbarWidth;
+        return new DimensionInfo(offsetWidth, clientWidth, scrollbarWidth);
     }
     static getClientWidth(element) {
         return this.getWidthInfo(element).clientSize;
     }
     static getHeightInfo(element) {
-        const offsetSize = SizeUtils.getOffsetHeight(element);
-        const style = getComputedStyle(element);
-        const inset = parseCssValue(style.borderTopWidth)
-            + parseCssValue(style.borderBottomWidth)
-            + parseCssValue(style.paddingTop)
-            + parseCssValue(style.paddingBottom);
-        const sizeWithScrollBar = offsetSize - inset;
-        const scrollBarSize = Math.round(sizeWithScrollBar) - element.clientHeight;
-        return new DimensionInfo(offsetSize, sizeWithScrollBar - scrollBarSize, scrollBarSize);
+        const computedStyle = getComputedStyle(element);
+        const offsetHeight = this.getOffsetHeight(element);
+        const offsetHeightWithoutBorder = offsetHeight
+            - parseCssValue(computedStyle.borderTopWidth)
+            - parseCssValue(computedStyle.borderBottomWidth);
+        let scrollbarWidth = 0;
+        if (Math.round(offsetHeightWithoutBorder) > element.clientHeight)
+            scrollbarWidth = SizeUtils.getScrollbarsWidth().horizontal;
+        const clientHeight = offsetHeightWithoutBorder - scrollbarWidth;
+        return new DimensionInfo(offsetHeight, clientHeight, scrollbarWidth);
     }
     static getClientHeight(element) {
         return this.getHeightInfo(element).clientSize;
@@ -107933,6 +108420,7 @@ class DimensionInfo {
 
 
 
+
 const SCROLL_INTERVAL_MS = 50;
 const CSSCLASS_FOCUSED = "dxreInFocus";
 const AUTOSCROLL_AREA_SIZE = 10;
@@ -108168,35 +108656,40 @@ class CanvasManager extends batch_updatable/* BatchUpdatableObject */.IS {
         const clientRect = canvas.getBoundingClientRect();
         const scaleX = this.getScale(clientRect.width, canvas.offsetWidth);
         const scaleY = this.getScale(clientRect.height, canvas.offsetHeight);
-        const clientX = utils_evt/* EvtUtils */.g.getEventX(evt) / scaleX;
-        const clientY = utils_evt/* EvtUtils */.g.getEventY(evt) / scaleY;
-        const canvasX = dom.DomUtils.getAbsolutePositionX(canvas) / scaleX;
-        const canvasY = dom.DomUtils.getAbsolutePositionY(canvas) / scaleY;
-        const offsetY = canvas.scrollTop / scaleY + clientY - canvasY;
-        const pageIndex = this.sizes.findPageIndexByOffsetY(this.viewManager.layout.pages, offsetY);
-        const visibleAreaWidth = this.sizes.getVisibleAreaWidth(false) / scaleX;
-        const visibleAreaHeight = this.sizes.getVisibleAreaHeight(false) / scaleY;
+        const clientX = MixedSize.fromUI(utils_evt/* EvtUtils */.g.getEventX(evt));
+        const clientY = MixedSize.fromUI(utils_evt/* EvtUtils */.g.getEventY(evt));
+        const canvasX = MixedSize.fromUI(dom.DomUtils.getAbsolutePositionX(canvas));
+        const canvasY = MixedSize.fromUI(dom.DomUtils.getAbsolutePositionY(canvas));
+        const offsetY = MixedSize.fromUI(canvas.scrollTop).addSize(clientY).subtractSize(canvasY).useScale(scaleY);
+        const pageIndex = this.viewManager.layout.findPageIndexByOffsetY(offsetY.LayoutSize * scaleY, this.sizes);
+        const visibleAreaWidth = MixedSize.fromUI(this.sizes.getVisibleAreaWidth(false));
+        const visibleAreaHeight = MixedSize.fromUI(this.sizes.getVisibleAreaHeight(false));
         if (checkScroll) {
-            if (this.sizes.scrollYVisible && canvasX + visibleAreaWidth - clientX < 0)
+            const relativeX = new MixedSize().useScale(scaleX).addSize(canvasX).addSize(visibleAreaWidth).subtractSize(clientX);
+            if (this.sizes.scrollYVisible && relativeX.LayoutSize < 0)
                 return LayoutPoint.Empty();
-            if (this.sizes.scrollXVisible && canvasY + visibleAreaHeight - clientY < 0)
+            const relativeY = new MixedSize().useScale(scaleY).addSize(canvasY).addSize(visibleAreaHeight).subtractSize(clientY);
+            if (this.sizes.scrollXVisible && relativeY.LayoutSize < 0)
                 return LayoutPoint.Empty();
         }
         const layoutPage = this.viewManager.layout.pages[pageIndex];
         const renderPageCacheElem = this.viewManager.cache[pageIndex];
         if (!layoutPage || !renderPageCacheElem)
             return LayoutPoint.Empty();
-        return new LayoutPoint(pageIndex, canvas.scrollLeft + clientX - (canvasX + renderPageCacheElem.page.offsetLeft), offsetY - this.sizes.getPageOffsetY(layoutPage));
+        const pageX = new MixedSize().useScale(scaleX).addUISize(canvas.scrollLeft).addSize(clientX).subtractSize(canvasX).subtractLayoutSize(renderPageCacheElem.page.offsetLeft).LayoutSize;
+        const pageY = new MixedSize().useScale(scaleY).addSize(offsetY).subtractLayoutSize(this.sizes.getPageOffsetY(layoutPage)).LayoutSize;
+        return new LayoutPoint(pageIndex, pageX, pageY);
     }
     isVisiblePosition(layoutPoint) {
-        const pages = this.viewManager.layout.pages;
-        this.scroll.updatePageIndexesInfo(pages);
+        const layout = this.viewManager.layout;
+        const zoomLevel = this.viewManager.zoomLevel;
+        this.scroll.updatePageIndexesInfo(layout);
         if (layoutPoint.pageIndex < this.scroll.startVisiblePageIndex || layoutPoint.pageIndex > this.scroll.endVisiblePageIndex)
             return false;
-        const pageY = this.sizes.getPageOffsetY(pages[layoutPoint.pageIndex]);
-        const pageX = this.viewManager.cache[layoutPoint.pageIndex].page.offsetLeft;
-        const x = pageX + layoutPoint.x;
-        const y = pageY + layoutPoint.y;
+        const pageY = MixedSize.fromLayout(this.sizes.getPageOffsetY(layout.pages[layoutPoint.pageIndex])).useScale(zoomLevel);
+        const pageX = MixedSize.fromLayout(this.viewManager.cache[layoutPoint.pageIndex].page.offsetLeft).useScale(zoomLevel);
+        const x = pageX.addLayoutSize(layoutPoint.x).UISize;
+        const y = pageY.addLayoutSize(layoutPoint.y).UISize;
         return x >= this.scroll.lastScrollLeft && x <= this.sizes.getVisibleAreaWidth(false) + this.scroll.lastScrollLeft &&
             y >= this.scroll.lastScrollTop && y <= this.sizes.getVisibleAreaHeight(false) + this.scroll.lastScrollTop;
     }
@@ -108244,17 +108737,23 @@ class CanvasManager extends batch_updatable/* BatchUpdatableObject */.IS {
     onScrollIntervalTick() {
         const evtX = this.lastMousePosition.x;
         const evtY = this.lastMousePosition.y;
-        const inHorizontalArea = evtX >= this.canvasPosition.x && evtX <= this.canvasPosition.x + this.sizes.getVisibleAreaWidth(true);
-        const inVerticalArea = evtY >= this.canvasPosition.y && evtY <= this.canvasPosition.y + this.sizes.getVisibleAreaHeight(true);
+        const inHorizontalArea = evtX >= this.canvasPosition.x && evtX <= this.canvasPosition.x + this.sizes.getVisibleAreaWidth(false);
+        const inVerticalArea = evtY >= this.canvasPosition.y && evtY <= this.canvasPosition.y + this.sizes.getVisibleAreaHeight(false);
         if (!inHorizontalArea && !inVerticalArea)
             return;
+        const yOffsetWithoutScrollbar = this.canvasPosition.y + this.sizes.getVisibleAreaHeight(false) - evtY;
+        const yOffsetWithScrollbar = this.canvasPosition.y + this.sizes.getVisibleAreaHeight(true) - evtY;
+        const outsideHorizontalScrollbar = yOffsetWithoutScrollbar > 0 || yOffsetWithScrollbar < 0;
         if (inHorizontalArea && evtY - this.canvasPosition.y <= AUTOSCROLL_AREA_SIZE)
             this.viewManager.canvas.scrollTop -= AUTOSCROLL_STEP;
-        else if (inHorizontalArea && this.canvasPosition.y + this.sizes.getVisibleAreaHeight(true) - evtY <= AUTOSCROLL_AREA_SIZE)
+        else if (inHorizontalArea && yOffsetWithoutScrollbar <= AUTOSCROLL_AREA_SIZE && outsideHorizontalScrollbar)
             this.viewManager.canvas.scrollTop += AUTOSCROLL_STEP;
+        const xOffsetWithoutScrollbar = this.canvasPosition.x + this.sizes.getVisibleAreaWidth(false) - evtX;
+        const xOffsetWithScrollbar = this.canvasPosition.x + this.sizes.getVisibleAreaWidth(true) - evtX;
+        const outsideVerticalScrollbar = xOffsetWithoutScrollbar > 0 || xOffsetWithScrollbar < 0;
         if (inVerticalArea && evtX - this.canvasPosition.x <= AUTOSCROLL_AREA_SIZE)
             this.viewManager.canvas.scrollLeft -= AUTOSCROLL_STEP;
-        else if (inVerticalArea && this.canvasPosition.x + this.sizes.getVisibleAreaWidth(true) - evtX <= AUTOSCROLL_AREA_SIZE)
+        else if (inVerticalArea && xOffsetWithoutScrollbar <= AUTOSCROLL_AREA_SIZE && outsideVerticalScrollbar)
             this.viewManager.canvas.scrollLeft += AUTOSCROLL_STEP;
     }
     static getCursorClassName(pointer) {
@@ -108298,10 +108797,12 @@ class CanvasManager extends batch_updatable/* BatchUpdatableObject */.IS {
         return ResizeBoxListener.directionToSource[className.substr(ind + cornerPrefix.length, 2).trim()];
     }
     getScrollTopInfo() {
-        const pages = this.viewManager.layout.pages;
         const scrollTop = this.viewManager.canvas.scrollTop;
-        const pageIndex = this.sizes.findPageIndexByOffsetY(pages, scrollTop);
-        return new ScrollTopInfo(pageIndex, scrollTop - this.sizes.getPageOffsetY(pages[pageIndex]));
+        const pageIndex = this.viewManager.layout.findPageIndexByOffsetY(scrollTop, this.sizes);
+        const pages = this.viewManager.layout.pages;
+        const zoomLevel = this.viewManager.zoomLevel;
+        const pageOffsetY = this.sizes.getPageOffsetY(pages[pageIndex]);
+        return new ScrollTopInfo(pageIndex, new MixedSize().useScale(zoomLevel).addUISize(scrollTop).subtractLayoutSize(pageOffsetY).LayoutSize);
     }
 }
 class ScrollTopInfo {
@@ -108315,6 +108816,7 @@ class ScrollTopInfo {
 
 
 
+
 class CanvasScrollInfo {
     constructor(canvas, sizes, internalApi) {
         this.lastScrollTop = -1;
@@ -108325,6 +108827,10 @@ class CanvasScrollInfo {
         this.internalApi = internalApi;
         this.init(canvas, sizes);
     }
+    modelChanged(change) {
+        if (change.type == ModelChangeType.ZoomLevelChanged)
+            this.onCanvasSizeChanged();
+    }
     init(canvas, sizes) {
         this.canvas = canvas;
         this.sizes = sizes;
@@ -108339,16 +108845,16 @@ class CanvasScrollInfo {
     renderPageIndexInterval() {
         return fixed.FixedInterval.fromPositions(this.getStartRenderPageIndex(), this.getEndRenderPageIndex() + 1);
     }
-    updatePageIndexesInfo(pages) {
-        if (!pages.length)
+    updatePageIndexesInfo(layout) {
+        if (!layout.pages.length)
             return;
         const scrollTop = this.getScrollTop();
         this.lastScrollLeft = this.canvas.scrollLeft;
         if (this.startVisiblePageIndex >= 0 && scrollTop == this.lastScrollTop && !this._needUpdatePageIndexes)
             return;
         this._needUpdatePageIndexes = false;
-        this.startVisiblePageIndex = this.sizes.findPageIndexByOffsetY(pages, scrollTop);
-        this.endVisiblePageIndex = this.sizes.findPageIndexByOffsetY(pages, scrollTop + this.getVisibleHeight());
+        this.startVisiblePageIndex = layout.findPageIndexByOffsetY(scrollTop, this.sizes);
+        this.endVisiblePageIndex = layout.findPageIndexByOffsetY(scrollTop + this.getVisibleHeight(), this.sizes);
         this.lastScrollTop = scrollTop;
     }
     getVisibleInterval() {
@@ -108376,6 +108882,8 @@ CanvasScrollInfo.VISIBLE_AREA_HEIGHT_MULTIPLIER = 2;
 
 
 
+
+
 class CanvasScrollManager {
     get canvas() { return this.viewManager.canvas; }
     get sizes() { return this.viewManager.sizes; }
@@ -108389,6 +108897,10 @@ class CanvasScrollManager {
         clearTimeout(this.updateScrollTimeoutId);
         clearTimeout(this.waitForDblClickTimeoutId);
     }
+    modelChanged(change) {
+        if (change.type == ModelChangeType.ZoomLevelChanged)
+            this.updateScrollVisibility();
+    }
     get scrollTop() { return this.canvas.scrollTop; }
     set scrollTop(val) { this.canvas.scrollTop = val; }
     setScrollEnabled(enabled) {
@@ -108407,46 +108919,48 @@ class CanvasScrollManager {
     scrollToX(canvasState) {
         const position = canvasState.lp;
         const relativePosition = canvasState.relativePosition;
-        let y = this.sizes.getPageOffsetY(this.viewManager.layout.pages[position.pageIndex]);
-        let height = 0;
+        const zoomLevel = this.viewManager.zoomLevel;
+        const page = this.viewManager.layout.pages[position.pageIndex];
+        let y = MixedSize.fromLayout(this.sizes.getPageOffsetY(page)).useScale(zoomLevel);
+        let height = new MixedSize().useScale(zoomLevel);
         if (position.detailsLevel >= DocumentLayoutDetailsLevel.PageArea) {
-            y += position.pageArea.y;
+            y.addLayoutSize(position.pageArea.y);
             if (position.detailsLevel >= DocumentLayoutDetailsLevel.Column) {
-                y += position.column.y;
+                y.addLayoutSize(position.column.y);
                 if (position.detailsLevel >= DocumentLayoutDetailsLevel.Row) {
-                    y += position.row.y;
+                    y.addLayoutSize(position.row.y);
                     if (relativePosition === RelativePosition.Bottom)
-                        y += position.row.height;
+                        y.addLayoutSize(position.row.height);
                     else if (relativePosition === RelativePosition.Inside)
-                        height = position.row.height;
+                        height.clear().addLayoutSize(position.row.height);
                 }
                 else if (relativePosition === RelativePosition.Bottom)
-                    y += position.column.height;
+                    y.addLayoutSize(position.column.height);
                 else if (relativePosition === RelativePosition.Inside)
-                    height = position.column.height;
+                    height.clear().addLayoutSize(position.column.height);
             }
             else if (relativePosition === RelativePosition.Bottom)
-                y += position.pageArea.height;
+                y.addLayoutSize(position.pageArea.height);
             else if (relativePosition === RelativePosition.Inside)
-                height = position.pageArea.height;
+                height.clear().addLayoutSize(position.pageArea.height);
         }
         else if (relativePosition === RelativePosition.Bottom)
-            y += position.page.height;
+            y.addLayoutSize(position.page.height);
         else if (relativePosition === RelativePosition.Inside)
-            height = position.page.height;
+            height.clear().addLayoutSize(position.page.height);
         if (relativePosition === RelativePosition.Bottom)
-            y -= this.sizes.getVisibleAreaHeight(false);
-        y += canvasState.getVerticalOffset(this.sizes);
+            y.subtractUISize(this.sizes.getVisibleAreaHeight(false));
+        y.addUISize(canvasState.getVerticalOffset(this.sizes));
         if (relativePosition === RelativePosition.Inside) {
             let scrollTop = this.canvas.scrollTop;
             const scrollVisibleAreaHeight = this.sizes.getVisibleAreaHeight(false);
-            if (y < scrollTop)
-                this.canvas.scrollTop = y;
-            else if (y + height > scrollVisibleAreaHeight + scrollTop)
-                this.canvas.scrollTop = y + height - scrollVisibleAreaHeight;
+            if (y.UISize < scrollTop)
+                this.canvas.scrollTop = y.UISize;
+            else if (y.UISize + height.UISize > scrollVisibleAreaHeight + scrollTop)
+                this.canvas.scrollTop = y.UISize + height.UISize - scrollVisibleAreaHeight;
         }
         else
-            this.canvas.scrollTop = y;
+            this.canvas.scrollTop = y.UISize;
     }
     NotifyScrollPositionChanged(canvasState) {
         if (this.updateScrollTimeoutId) {
@@ -108475,14 +108989,14 @@ class CanvasScrollManager {
 
 
 
-
 class CanvasSizeInfo {
-    constructor() {
+    constructor(zoomLevelHolder) {
         this.topSpacing = -1;
         this.betweenPageSpacing = 1;
         this.visibleAreaSize = new geometry_size.Size(-1, -1);
         this.scrollWidth = -1;
         this.pageVerticalInfo = new RenderPageVertivalInfo();
+        this.zoomLevelHolder = zoomLevelHolder;
         this.scrollWidth = dom.DomUtils.getVerticalScrollBarWidth();
     }
     isInitialized() {
@@ -108494,12 +109008,10 @@ class CanvasSizeInfo {
         this.betweenPageSpacing = this.pageVerticalInfo.betweenPageSpacing;
         this.setVisibleAreaSize(SizeUtils.getClientWidth(canvas), SizeUtils.getClientHeight(canvas));
     }
-    findPageIndexByOffsetY(pages, offsetY) {
-        return Math.max(0, search.SearchUtils.normedInterpolationIndexOf(pages, (p) => this.getPageOffsetY(p), offsetY));
-    }
     getPageOffsetY(layoutPage) {
         return layoutPage.y + (this.topSpacing + layoutPage.index * this.betweenPageSpacing);
     }
+    get zoomLevel() { return this.zoomLevelHolder.zoomLevel; }
     setVisibleAreaSize(width, height) {
         this.visibleAreaSize.width = width;
         this.visibleAreaSize.height = height;
@@ -108671,9 +109183,9 @@ class PrintLayoutViewCanvasListener extends CanvasListener {
             Log.paramsHolder.visualizerManager.show(DebugVisualizerType.LayoutBounds, this.layout, p.index); }));
     }
     updateVisiblePages() {
-        const pages = this.layout.pages;
-        this.viewManager.scroll.updatePageIndexesInfo(pages);
+        this.viewManager.scroll.updatePageIndexesInfo(this.layout);
         const renderInterval = this.viewManager.scroll.renderPageIndexInterval();
+        const pages = this.layout.pages;
         for (let pageIndex of this.handledPageIndexes)
             if (!renderInterval.contains(pageIndex)) {
                 const page = pages[pageIndex];
@@ -109764,6 +110276,16 @@ class SelectionRenderer extends SelectionRendererBase {
     }
 }
 
+;// CONCATENATED MODULE: ./src/common/model/changes/model/zoom-level.ts
+
+class ZoomLevelChange {
+    constructor(zoomLevel, prevZoomLevel) {
+        this.zoomLevel = zoomLevel;
+        this.prevZoomLevel = prevZoomLevel;
+        this.type = ModelChangeType.ZoomLevelChanged;
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/common/canvas/renderes/view-manager.ts
 
 
@@ -109789,6 +110311,9 @@ class SelectionRenderer extends SelectionRendererBase {
 
 
 
+
+
+
 
 
 
@@ -109799,7 +110324,7 @@ class ViewManager {
     get canvasListener() { return this.canvasListeners[this.innerClientProperties.viewsSettings.viewType]; }
     constructor(control, canvas, eventManager, stringResources, horizontalRuler, inputController, innerClientProperties, readOnlyPropertyHolder, layoutFormatterManagerHolder, internalApi, fieldOptions) {
         this.cache = [];
-        this.sizes = new CanvasSizeInfo();
+        this.sizes = new CanvasSizeInfo(this);
         this.control = control;
         this.readOnlyPropertyHolder = readOnlyPropertyHolder;
         this.layoutFormatterManagerHolder = layoutFormatterManagerHolder;
@@ -109834,6 +110359,13 @@ class ViewManager {
         this.selection.dispose();
         this.pagesContainer = null;
     }
+    modelChanged(change) {
+        if (change.type == ModelChangeType.ZoomLevelChanged) {
+            this.canvas.scrollTop = this.canvas.scrollTop / change.prevZoomLevel * change.zoomLevel;
+            this.pagesContainer.style.zoom = change.zoomLevel.toString();
+            this.sizes.updateSize(this.canvas);
+        }
+    }
     adjust(force) {
         if ((force || !this.sizes.isInitialized()) && this.cache.length > 0) {
             const firstRenderedPageIndex = Math.min(this.cache.length, Math.max(0, utils_list.ListUtils.indexBy(this.layout.pages, (page) => page.flags.get(LayoutPageFlags.ContentRendered))));
@@ -109871,7 +110403,9 @@ class ViewManager {
             const pageInfo = layoutSelection.selectionInfo.pageInfos[pageIndex];
             const item = pageInfo.oldItems[0];
             const layoutPage = this.layout.pages[pageIndex];
-            this.inputController.setPosition(layoutPage.x + this.cache[pageIndex].page.offsetLeft + item.x, this.sizes.getPageOffsetY(layoutPage) + item.y);
+            const x = MixedSize.fromLayout(layoutPage.x + this.cache[pageIndex].page.offsetLeft + item.x).useScale(this.zoomLevel);
+            const y = MixedSize.fromLayout(this.sizes.getPageOffsetY(layoutPage) + item.y).useScale(this.zoomLevel);
+            this.inputController.setPosition(x.UISize, y.UISize);
         }
     }
     NotifySearchSelectionLayoutChanged() {
@@ -109936,12 +110470,9 @@ class ViewManager {
     }
     get zoomLevel() { return this.innerClientProperties.viewsSettings.zoomLevel; }
     set zoomLevel(value) {
-        this.pagesContainer.style.zoom = value.toString();
+        const prevZoomLevel = this.zoomLevel;
         this.innerClientProperties.viewsSettings.zoomLevel = value;
-        if (this.control.innerClientProperties.viewsSettings.isSimpleView) {
-            this.canvasManager.simpleViewCanvasSizeManager.changeSize(true);
-        }
-        this.control.horizontalRulerControl.update();
+        this.control.modelManager.modelManipulator.notifyModelChanged(new ZoomLevelChange(this.zoomLevel, prevZoomLevel));
     }
     get allowZoom() { return ControlOptions.isEnabled(this.control.modelManager.richOptions.control.allowZoom); }
     set allowZoom(value) {
@@ -110564,17 +111095,17 @@ class InputEditorBase {
         clearTimeout(this.onKeyUpTimerId);
     }
     initialize() {
-        this.initializeIfNotReadOnly();
+        this.initializeEditableState();
         this.initEvents();
         this.prevKeyCode = EMPTY_KEYCODE;
     }
-    initializeIfNotReadOnly() {
-        if ((this.control.readOnly !== ReadOnlyMode.Persistent || this.control.modelManager.clientMode) && !this.initializedIfNotReadOnly) {
-            this.initializedIfNotReadOnly = true;
-            this.initializeIfNotReadOnlyCore();
+    initializeEditableState() {
+        if (!this.editableStateInitialized) {
+            this.editableStateInitialized = true;
+            this.initializeEditableStateCore();
         }
     }
-    initializeIfNotReadOnlyCore() {
+    initializeEditableStateCore() {
     }
     initEvents() {
         this.evtHandlersHolder.addListener(this.getEditableDocument(), "keydown", this.onKeyDown.bind(this));
@@ -110794,8 +111325,8 @@ class DivInputEditor extends InputEditorBase {
         clearTimeout(this.composEndTimerId);
         clearTimeout(this.onTextInputTimerId);
     }
-    initializeIfNotReadOnlyCore() {
-        this.inputElement.contentEditable = "true";
+    initializeEditableStateCore() {
+        this.inputElement.contentEditable = String(!this.control.isReadOnlyPersistent);
         this.clearInputElement();
     }
     setPosition(left, top) {
@@ -111043,11 +111574,11 @@ class IFrameInputEditor extends InputEditorBase {
         body.style.margin = "0px";
         body.style.overflow = "hidden";
     }
-    initializeIfNotReadOnlyCore() {
+    initializeEditableStateCore() {
         if (browser.Browser.WebKitFamily)
-            this.editableDocument.body.setAttribute("contenteditable", "true");
+            this.editableDocument.body.setAttribute("contenteditable", String(!this.control.isReadOnlyPersistent));
         else
-            this.editableDocument.designMode = "on";
+            this.editableDocument.designMode = this.control.isReadOnlyPersistent ? "off" : "on";
     }
     createInputElement() {
         const element = document.createElement("IFRAME");
@@ -111186,7 +111717,7 @@ class IFrameInputEditor extends InputEditorBase {
     recreateIfNeeded() {
         const iframeDocument = this.inputElement.contentDocument || this.inputElement.contentWindow.document;
         if (!iframeDocument.body.hasAttribute("loaded")) {
-            this.initializedIfNotReadOnly = false;
+            this.editableStateInitialized = false;
             this.createHierarchyCore();
             this.initialize();
         }
@@ -111221,6 +111752,7 @@ class IFrameInputEditor extends InputEditorBase {
     }
     startInputIME() {
         this.inputElement.style.position = "absolute";
+        this.inputElement.style.zoom = this.control.viewManager.zoomLevel;
         const lastSelectedIntervalStartPosition = this.control.selection.lastSelectedInterval.start;
         const subDocument = this.control.selection.activeSubDocument;
         const layoutPosition = subDocument.isMain() ?
@@ -111234,6 +111766,9 @@ class IFrameInputEditor extends InputEditorBase {
         const propChar = HtmlConverter.getSizeSignificantRules(this.control.inputPosition.getMergedCharacterPropertiesRaw()).join(";");
         this.editableDocument.body.style.cssText = "padding: 0px; margin: 0px; overflow: hidden; color: transparent; " + propChar;
         this.editableDocument.body.style.textIndent = currentTextIndent;
+        if (browser.Browser.Firefox && browser.Browser.Version <= 137) {
+            this.editableDocument.body.style.zoom = this.control.viewManager.zoomLevel;
+        }
         let layoutX = layoutPosition.getLayoutX(this.control.measurer, DocumentLayoutDetailsLevel.Row);
         const layoutPoint = new LayoutPoint(layoutPosition.pageIndex, layoutX, layoutPosition.getLayoutY(DocumentLayoutDetailsLevel.Row));
         const pageElement = this.control.viewManager.cache[layoutPoint.pageIndex].page;
@@ -112493,6 +113028,7 @@ class RulerMultiControl {
 
 
 
+
 const TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME = " table";
 var SnapTo;
 (function (SnapTo) {
@@ -112525,7 +113061,7 @@ class RulerVerticalLineControl {
             dom.DomUtils.addClassName(this.rootElement, TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME);
         else
             dom.DomUtils.removeClassName(this.rootElement, TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME);
-        this.rootElement.style.height = this.canvas.clientHeight + "px";
+        this.rootElement.style.height = SizeUtils.getClientHeight(this.canvas) + "px";
         this.rootElement.style.top = this.canvas.offsetTop + "px";
         this.rulerControlLeft = this.rulerControlElement.offsetLeft;
         this.rulerControlWidth = this.rulerControlElement.offsetWidth;
@@ -113585,13 +114121,9 @@ class RulerControl extends RulerBase {
     }
     adjust() {
         const viewWidth = this.controls.canvas.clientWidth;
-        if (viewWidth > this.pageWidth)
-            this.initialMarginLeftElement = (viewWidth - this.pageWidth - RULLER_NUMBER_CORRECTION * 2) / 2;
-        else {
-            const paddingLeft = dom.DomUtils.pxToInt(dom.DomUtils.getCurrentStyle(this.controls.canvas).paddingLeft);
-            const pageAreaBorderWidth = (this.controls.canvas.scrollWidth - paddingLeft - this.pageWidth) / 2;
-            this.initialMarginLeftElement = paddingLeft + pageAreaBorderWidth - RULLER_NUMBER_CORRECTION;
-        }
+        const paddingLeft = dom.DomUtils.pxToInt(dom.DomUtils.getCurrentStyle(this.controls.canvas).paddingLeft);
+        const minValue = paddingLeft - RULLER_NUMBER_CORRECTION;
+        this.initialMarginLeftElement = Math.max((viewWidth - this.pageWidth - RULLER_NUMBER_CORRECTION * 2) / 2, minValue);
         this.rootElement.style.left = this.calculateLeftOffset();
         this.setPaddings();
         this.canHandleScroll = this.controls.canvas.scrollWidth > this.controls.canvas.offsetWidth;
@@ -115288,6 +115820,8 @@ class HorizontalRulerControl extends batch_updatable/* BatchUpdatableObject */.I
             case ModelChangeType.TableCellRemoved:
             case ModelChangeType.TableCellInserted:
                 return HorizontalRulerEventType.FullReset;
+            case ModelChangeType.ZoomLevelChanged:
+                return HorizontalRulerEventType.FullReset;
             default:
                 return HorizontalRulerEventType.None;
         }
@@ -115566,7 +116100,7 @@ class SearchManager {
 
 
 class RichEditCore {
-    get isReadOnlyPersistent() { return this.readOnly == ReadOnlyMode.Persistent; }
+    get isReadOnlyPersistent() { return this.readOnly === ReadOnlyMode.Persistent; }
     get model() { return this.modelManager.model; }
     get isDisposed() {
         return this._isDisposed;
@@ -115661,15 +116195,19 @@ class RichEditCore {
         ]);
         this.modelManager.modelManipulator.clearListeners();
         this.modelManager.history.clear();
-        this.modelManager.modelManipulator.modelListeners.push(this.inputPositionModelChangesListener);
-        this.modelManager.modelManipulator.modelListeners.push(this.layoutFormatterManager.modelChangesListener);
-        this.modelManager.modelManipulator.modelListeners.push(this.selectionModelChangesListener);
-        this.modelManager.modelManipulator.modelListeners.push(new SpellCheckerModelChangesListener(this.spellChecker));
+        this.modelManager.modelManipulator.addModelListener(this.inputPositionModelChangesListener);
+        this.modelManager.modelManipulator.addModelListener(this.layoutFormatterManager.modelChangesListener);
+        this.modelManager.modelManipulator.addModelListener(this.selectionModelChangesListener);
+        this.modelManager.modelManipulator.addModelListener(new SpellCheckerModelChangesListener(this.spellChecker));
         if (this.barHolder.ribbon)
-            this.modelManager.modelManipulator.modelListeners.push(this.barHolder.ribbon);
-        this.modelManager.modelManipulator.modelListeners.push(this.barHolder.contextMenu);
-        this.modelManager.modelManipulator.modelListeners.push(this.horizontalRulerControl);
-        this.modelManager.modelManipulator.modelListeners.push(this.selectionFormatter);
+            this.modelManager.modelManipulator.addModelListener(this.barHolder.ribbon);
+        this.modelManager.modelManipulator.addModelListener(this.barHolder.contextMenu);
+        this.modelManager.modelManipulator.addModelListener(this.horizontalRulerControl);
+        this.modelManager.modelManipulator.addModelListener(this.selectionFormatter);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager.canvasManager.simpleViewCanvasSizeManager);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager.canvasScrollManager);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager.scroll);
         this.registerFontChangesListeners();
         this.selection.onChanged.add(this.searchManager);
         this.selection.onChanged.add(this.boxVisualizerManager.resizeBoxVisualizer);
@@ -115686,8 +116224,8 @@ class RichEditCore {
         this.selection.onChanged.add(this.globalEventDispatcher);
         this.selection.onChanged.add(this.barHolder.publicUiChangesListener);
         this.registerActiveContextTabManager();
-        this.modelManager.modelManipulator.modelListeners.push(this.globalEventDispatcher);
-        this.modelManager.modelManipulator.modelListeners.push(this.barHolder.publicUiChangesListener);
+        this.modelManager.modelManipulator.addModelListener(this.globalEventDispatcher);
+        this.modelManager.modelManipulator.addModelListener(this.barHolder.publicUiChangesListener);
         this.inputController.initExporter();
     }
     dispose() {
@@ -115775,8 +116313,8 @@ class RichEditCore {
             this.readOnly = ReadOnlyMode.Persistent;
         else if (!readOnly && this.readOnly === ReadOnlyMode.Persistent) {
             this.readOnly = ReadOnlyMode.None;
-            this.inputController.inputEditor.initializeIfNotReadOnly();
         }
+        this.inputController.inputEditor.initializeEditableStateCore();
     }
     setWorkSession(sessionGuid, documentInfo) {
         this.sessionGuid = sessionGuid;
@@ -115810,12 +116348,7 @@ class RichEditCore {
     }
     closeDocument() {
         this.selection.onChanged.remove(this.globalEventDispatcher);
-        for (let ind = 0; ind < this.modelManager.modelManipulator.modelListeners.length; ind++) {
-            if (this.modelManager.modelManipulator.modelListeners[ind] == this.globalEventDispatcher) {
-                this.modelManager.modelManipulator.modelListeners.splice(ind, 1);
-                break;
-            }
-        }
+        this.modelManager.modelManipulator.removeModelListener(this.globalEventDispatcher);
         this.barHolder.setEnabled(false);
         if (this.horizontalRulerControl)
             this.horizontalRulerControl.setEnable(false);
@@ -115902,6 +116435,7 @@ class RichEditCore {
             pictureRenderer: this.viewManager.renderer,
             uiUnitConverter: this.uiUnitConverter,
             lastMaxNumPages: this.layout.lastMaxNumPages,
+            grids: this.layout.grids,
             pageIndex: this.selection.pageIndex,
             sessionGuid: this.sessionGuid,
             clientGuid: this.clientGuid,
@@ -117601,7 +118135,6 @@ var ViewTabCommandId;
     ViewTabCommandId[ViewTabCommandId["ToggleShowHorizontalRuler"] = 94] = "ToggleShowHorizontalRuler";
     ViewTabCommandId[ViewTabCommandId["ToggleFullScreen"] = 98] = "ToggleFullScreen";
     ViewTabCommandId[ViewTabCommandId["ChangeZoomLevel"] = 460] = "ChangeZoomLevel";
-    ViewTabCommandId[ViewTabCommandId["ToggleAllowZoom"] = 461] = "ToggleAllowZoom";
 })(ViewTabCommandId || (ViewTabCommandId = {}));
 var HeaderAndFooterTabCommandId;
 (function (HeaderAndFooterTabCommandId) {
@@ -122676,6 +123209,7 @@ function createInnerItems(items) {
 }
 
 ;// CONCATENATED MODULE: ./src/client/utils/focus-helper.ts
+var focus_helper_a;
 class FocusHelper {
     static preventFocusOnClick(element) {
         return new FocusBlocker(element);
@@ -122688,23 +123222,24 @@ class FocusBlocker {
         this.addEventListeners(target);
     }
     addEventListeners(element) {
-        element.addEventListener("pointerdown", this.onPointerDownBinded);
+        element.addEventListener("mousedown", this.onPointerDownBinded);
     }
     removeEventListeners(element) {
-        element.removeEventListener("pointerdown", this.onPointerDownBinded);
+        element.removeEventListener("mousedown", this.onPointerDownBinded);
     }
     onPointerDown(event) {
         for (const element of event.composedPath()) {
-            if (!(element instanceof HTMLElement))
-                continue;
             if (element === this.target) {
                 event.preventDefault();
                 break;
             }
-            if (!this.target.contains(element) || element.tabIndex > -1)
+            if (element instanceof Element && this.isFocusableElement(element))
                 break;
         }
     }
+    isFocusableElement(element) {
+        return element.matches(FocusBlocker.focusableSelector);
+    }
     dispose() {
         if (this.target) {
             this.removeEventListeners(this.target);
@@ -122712,6 +123247,21 @@ class FocusBlocker {
         }
     }
 }
+focus_helper_a = FocusBlocker;
+FocusBlocker.focusableSelectors = [
+    'a[href]',
+    'area[href]',
+    'input',
+    'select',
+    'textarea',
+    'button',
+    'iframe',
+    'object',
+    'embed',
+    '[tabindex]:not([tabindex="-1"])',
+    '[contenteditable]:not([contenteditable="false"])'
+];
+FocusBlocker.focusableSelector = focus_helper_a.focusableSelectors.join(',');
 
 ;// CONCATENATED MODULE: ./src/client/bars/ribbon.ts
 
@@ -128230,8 +128780,18 @@ class PrintDocumentOnClient extends CommandBase {
         return true;
     }
     printCore(htmlPrinting, printWindow, closePrintDialogWithHtmlPreview, needSwitchViewType, needToggleHiddenSymbols) {
-        if (htmlPrinting)
-            this.generatePrintDocument(printWindow, closePrintDialogWithHtmlPreview);
+        if (htmlPrinting) {
+            this.generatePrintDocument(printWindow.document);
+            printWindow.focus();
+            const interval = setInterval(() => {
+                if (printWindow.document.readyState == 'complete') {
+                    printWindow.print();
+                    if (closePrintDialogWithHtmlPreview && !browser.Browser.AndroidMobilePlatform)
+                        printWindow.close();
+                    clearInterval(interval);
+                }
+            }, 100);
+        }
         else {
             pdfExport(this.control, (blob, _stream) => {
                 if (window.navigator.msSaveOrOpenBlob && !browser.Browser.Edge)
@@ -128246,12 +128806,27 @@ class PrintDocumentOnClient extends CommandBase {
             this.control.commandManager.getCommand(RichEditClientCommand.ToggleShowWhitespace).execute(this.control.commandManager.isPublicApiCall);
         this.control.commandManager.isPrintingProcessing = false;
     }
-    generatePrintDocument(printWindow, closePrintDialogWithHtmlPreview) {
+    generatePrintDocument(document) {
         const height = this.control.layout.pages[0].height;
         const width = this.control.layout.pages[0].width;
-        let printWindowContent = `<!DOCTYPE html>
-                <html moznomarginboxes mozdisallowselectionprint>
+        let fontLink = "";
+        let divsToLoadFonts = "";
+        const googleFonts = this.getGoogleFonts();
+        if (googleFonts.length > 0) {
+            fontLink = this.createGoogleFontStyleLink(googleFonts);
+            divsToLoadFonts = googleFonts.reduce((prev, curr) => {
+                const fontStyles = [`font-family:${curr}`, 'font-weight:bold', 'font-style:italic'];
+                const result = [];
+                for (let i = 1; i <= fontStyles.length; i++)
+                    result.push(`<div style="font-size:1pt;position:absolute;top:-1000px;${fontStyles.slice(0, i).join(';')}">${curr}</div>`);
+                return prev ? [prev, ...result].join('\n') : result.join('\n');
+            }, null);
+        }
+        document.documentElement.innerHTML =
+            `<!DOCTYPE html>
+            <html moznomarginboxes mozdisallowselectionprint>
                 <head>
+                    ${fontLink}
                     <style ${this._nonce ? `nonce="${this._nonce}"` : ''}>
                         html, body {
                             margin: 0;
@@ -128270,22 +128845,25 @@ class PrintDocumentOnClient extends CommandBase {
                     </style>
                 </head>
                 <body>
+                    ${divsToLoadFonts}
                 </body>
-                </html>`;
-        printWindow.document.write(printWindowContent);
-        printWindow.document.close();
+            </html>`;
         this.generatePrintContent().forEach((child) => {
-            printWindow.document.body.appendChild(child);
+            document.body.appendChild(child);
         });
-        printWindow.focus();
-        const interval = setInterval(() => {
-            if (printWindow.document.readyState == 'complete') {
-                printWindow.print();
-                if (closePrintDialogWithHtmlPreview && !browser.Browser.AndroidMobilePlatform)
-                    printWindow.close();
-                clearInterval(interval);
-            }
-        }, 100);
+    }
+    getGoogleFonts() {
+        return this.control.modelManager.richOptions.fonts.fonts.reduce((res, f) => {
+            if (f.useGoogleFonts)
+                res.push(f.fontFamily);
+            return res;
+        }, []);
+    }
+    createGoogleFontStyleLink(fontFamilies) {
+        const url = new URL('https://fonts.googleapis.com/css');
+        url.searchParams.append('family', fontFamilies.join('|'));
+        url.searchParams.append('display', 'auto');
+        return `<link href="${url.toString()}" rel="stylesheet" />`;
     }
     generatePrintContent() {
         const layout = this.control.layout;
@@ -129778,7 +130356,7 @@ class ApplyStyleCommand extends CommandBase {
                 paragraphStyle = StylesManager.getPresetParagraphStyleByName(styleName).clone();
                 isPresetStyle = true;
             }
-            this.applyParagraphStyle(subDocumentInterval, paragraphStyle, isPresetStyle, parameter.keepDirectFormatting);
+            this.applyParagraphStyle(subDocumentInterval, paragraphStyle, isPresetStyle, parameter.keepCustomFormatting);
         }
         else if (!StylesManager.isParagraphStyle(parameter.styleName) && state.characterStyleChangeEnabled) {
             const styleName = StylesManager.getStyleNameWithoutPrefix(parameter.styleName);
@@ -129813,7 +130391,7 @@ class ApplyStyleCommand extends CommandBase {
             this.modelManipulator.style.applyCharacterStyle(subDocumentInterval, characterStyle, false);
         }
     }
-    applyParagraphStyle(subDocumentInterval, style, isPresetStyle, keepDirectFormatting = false) {
+    applyParagraphStyle(subDocumentInterval, style, isPresetStyle, keepCustomFormatting = false) {
         const count = this.calculateAffectedParagraphCount(subDocumentInterval);
         if (count > 0 && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.paragraphStyle)) {
             const { interval, subDocument } = subDocumentInterval;
@@ -129826,8 +130404,7 @@ class ApplyStyleCommand extends CommandBase {
                 style = isPresetStyle ? modelManipulator.model.stylesManager.addParagraphStyle(style) : style;
                 this.history.addAndRedo(new ApplyParagraphStyleHistoryItem(modelManipulator, paragraphSubDocumentInterval, style));
                 this.history.addAndRedo(new ParagraphUseValueHistoryItem(modelManipulator, paragraphSubDocumentInterval, 0));
-                if (!keepDirectFormatting)
-                    this.history.addAndRedo(new FontUseValueHistoryItem(modelManipulator, paragraphSubDocumentInterval, 0));
+                this.history.addAndRedo(new FontUseValueHistoryItem(modelManipulator, paragraphSubDocumentInterval, 0, keepCustomFormatting));
                 this.history.addAndRedo(new AddParagraphToListHistoryItem(modelManipulator, subDocument, paragraphIndex, NumberingList.NumberingListNotSettedIndex, -1));
             }
         }
@@ -129867,25 +130444,6 @@ class ApplyStyleCommand extends CommandBase {
     }
 }
 
-;// CONCATENATED MODULE: ./src/common/commands/layout/toggle-allow-zoom-command.ts
-
-
-class ToggleAllowZoomCommand extends CommandBase {
-    getState() {
-        return new SimpleCommandState(this.isEnabled(), this.control.viewManager.allowZoom);
-    }
-    executeCore(_state, options) {
-        const allowZoom = this.control.viewManager.allowZoom;
-        if (options.param === allowZoom)
-            return false;
-        this.control.viewManager.allowZoom = !allowZoom;
-        return true;
-    }
-    isEnabledInReadOnlyMode() {
-        return true;
-    }
-}
-
 ;// CONCATENATED MODULE: ./src/common/commands/layout/change-zoom-level-command.ts
 
 
@@ -136415,7 +136973,7 @@ class SetParagraphLevelCommandBase extends CommandBase {
         if (!paragraphStyle)
             paragraphStyle = StylesManager.getPresetParagraphStyleByName(styleName);
         if (paragraphStyle) {
-            const commandOptions = new CommandSimpleOptions(this.control, { styleName: StylesManager.paragraphPrefix + styleName, keepDirectFormatting: true });
+            const commandOptions = new CommandSimpleOptions(this.control, { styleName: StylesManager.paragraphPrefix + styleName, keepCustomFormatting: true });
             this.commandManager.getCommand(RichEditClientCommand.ChangeStyle).execute(this.commandManager.isPublicApiCall, commandOptions);
         }
         else {
@@ -136678,7 +137236,6 @@ class UndoCommand extends CommandBase {
 
 
 
-
 
 
 class CommandManager {
@@ -137064,7 +137621,6 @@ class CommandManager {
         this.createCommand(control, RichEditClientCommand.SwitchToSimpleView, SwitchToSimpleViewCommand);
         this.createCommand(control, RichEditClientCommand.SwitchToPrintLayoutView, SwitchToPrintLayoutViewCommand);
         this.createCommand(control, RichEditClientCommand.ChangeZoomLevel, ChangeZoomLevelCommand);
-        this.createCommand(control, RichEditClientCommand.ToggleAllowZoom, ToggleAllowZoomCommand);
         this.createCommand(control, RichEditClientCommand.ShowErrorLoadPictureMessage, ShowLoadPictureErrorDialogCommand);
         this.assingCommand(RichEditClientCommand.PrintDocumentOnClient, new PrintDocumentOnClient(control, printNonce));
     }
@@ -137347,7 +137903,8 @@ class MailMergeCommand extends CommandBase {
         return true;
     }
     executeCore(_state, options) {
-        const docxExporter = new DocxExporter(this.control.modelManager.modelManipulator, new DocxExportOptions());
+        const exportModelOptions = this.control.getExportModelOptions();
+        const docxExporter = new DocxExporter(exportModelOptions, new DocxExportOptions());
         docxExporter.exportToBlob((blob) => {
             const docxImporter = new Importer(new ImporterOptions());
             docxImporter.importFromFile(blob, this.control.modelManager.richOptions, (documentModel, formatImagesImporter) => {
@@ -137491,191 +138048,6 @@ class MailMergeCommandParameters {
     }
 }
 
-;// CONCATENATED MODULE: ./src/common/model/fonts/google-fonts.ts
-
-
-
-
-
-class GoogleFontsApi {
-    constructor(controlFontsCache, fonts) {
-        this.fontFamilyToFontInfo = {};
-        this.fonts = fonts;
-        this.controlFontsCache = controlFontsCache;
-        const params = this.fonts.map(font => {
-            const fontFamily = font.getFontFamilies()[0];
-            this.fontFamilyToFontInfo[fontFamily] = font;
-            return `${fontFamily.replace(' ', '+')}:regular,bold,italic,bolditalic`;
-        }).join('|');
-        this.uri = `https://fonts.googleapis.com/css?family=${params}`;
-    }
-    loadControlFonts(callback) {
-        const notLoaded = () => callback([]);
-        const xhr = new XMLHttpRequest();
-        xhr.onload = (_e) => {
-            const responce = xhr.response;
-            if (xhr.status >= 400 || !responce)
-                notLoaded();
-            else
-                callback(this.parseResponce(responce));
-        };
-        xhr.onerror = () => notLoaded();
-        xhr.open("GET", this.uri, true);
-        xhr.responseType = "text";
-        xhr.send();
-    }
-    parseResponce(responce) {
-        const result = [];
-        let regexpResult;
-        const regexp = /@font-face\s*\{([\s\S]*?)\}/gm;
-        while (regexpResult = regexp.exec(responce)) {
-            const fontInfo = regexpResult[1];
-            const fontFamily = fontInfo.match(/font-family:\s*'(\w+\s*\w*)';/);
-            if (fontFamily && fontFamily[1]) {
-                const url = GoogleFontsApi.parseSrc(fontInfo.match(/src:\s*(.+);/));
-                const fontStyle = fontInfo.match(/font-style:\s*(\w+);/);
-                const fontWeight = fontInfo.match(/font-weight:\s*(.+);/);
-                const unicodeRange = fontInfo.match(/unicode-range:\s*(.+);/);
-                const desc = new FontFaceDescriptors();
-                if (fontStyle && fontStyle[1])
-                    desc.style = fontStyle[1];
-                if (fontWeight && fontWeight[1])
-                    desc.weight = fontWeight[1];
-                if (unicodeRange && unicodeRange[1])
-                    desc.unicodeRange = unicodeRange[1];
-                const controlFont = this.controlFontsCache.addFont(new ControlFont(fontFamily[1], desc));
-                if (url && utils_list.ListUtils.allOf(controlFont.sourceUrls, s => s != url)) {
-                    controlFont.sourceUrls.unshift(url);
-                    const fontInfo = this.fontFamilyToFontInfo[controlFont.fontFamily];
-                    const controlFontType = new class_flag.Flag();
-                    controlFontType.set(ControlFontType.Bold, controlFont.descriptors.msWordBold());
-                    controlFontType.set(ControlFontType.Italic, controlFont.descriptors.msWordItalic());
-                    fontInfo.controlFontMap[controlFontType.getValue()] = controlFont.cacheKey;
-                    result.push(controlFont);
-                }
-            }
-        }
-        return result;
-    }
-    static parseSrc(matchSrc) {
-        if (matchSrc && matchSrc[1])
-            for (let src of matchSrc[1].split(',')) {
-                const matchUrl = src.match(/url\((.+)\)\s*format\('(\w+)'\)/);
-                if (matchUrl)
-                    return matchUrl[1];
-            }
-        return null;
-    }
-}
-
-;// CONCATENATED MODULE: ./src/common/model/creator/cache.ts
-
-
-class ModelCacheFiller {
-    constructor(model, fontsSettings) {
-        this.model = model;
-        this.fontsSettings = fontsSettings;
-    }
-    fillCache() {
-        this.makeFontMap();
-        this.replaceCharProperties(this.model, "defaultCharacterProperties");
-        this.model.characterStyles.forEach(style => this.replaceCharProperties(style, "maskedCharacterProperties"));
-        this.model.paragraphStyles.forEach(style => this.replaceCharProperties(style, "maskedCharacterProperties"));
-        this.model.tableStyles.forEach(style => {
-            this.replaceCharProperties(style.baseConditionalStyle, 'maskedCharacterProperties');
-            number/* NumberMapUtils */.j.forEach(style.conditionalStyles, style => this.replaceCharProperties(style, 'maskedCharacterProperties'));
-        });
-        number/* NumberMapUtils */.j.forEach(this.model.subDocuments, sd => this.replaceInModelSubDocument(sd));
-    }
-    makeFontMap() {
-        const fontInfoCache = this.model.cache.fontInfoCache;
-        const fontsSettings = this.fontsSettings;
-        this.fontMap = Object.create(null);
-        fontInfoCache.getAllFonts().forEach(font => this.fontMap[font.name] = fontsSettings.getPermittedFont(fontInfoCache, font));
-    }
-    replaceCharProperties(object, propKey) {
-        const props = object[propKey];
-        props.fontInfo = props.fontInfo ? this.fontMap[props.fontInfo.name] : this.model.defaultCharacterProperties.fontInfo;
-        if (props instanceof MaskedCharacterProperties)
-            object[propKey] = this.model.cache.maskedCharacterPropertiesCache.getItem(props);
-        else
-            object[propKey] = this.model.cache.mergedCharacterPropertiesCache.getItem(props);
-    }
-    replaceInModelSubDocument(sd) {
-        sd.paragraphs.forEach(p => p.resetParagraphMergedProperties());
-        sd.chunks.forEach(chunk => {
-            chunk.textRuns.forEach(run => {
-                this.replaceCharProperties(run, 'maskedCharacterProperties');
-                run.resetCharacterMergedProperties();
-            });
-        });
-    }
-}
-
-;// CONCATENATED MODULE: ./src/common/model/creator/font-corrector.ts
-
-
-
-
-
-
-
-class FontCorrector {
-    get fontInfoCache() {
-        return this.model.cache.fontInfoCache;
-    }
-    get controlFontsCache() {
-        return this.model.cache.controlFontsCache;
-    }
-    constructor(modelManipulator, model, fonts) {
-        this.modelManipulator = modelManipulator;
-        this.model = model;
-        this.fonts = fonts;
-    }
-    correct() {
-        this.addAndLoad();
-        new ModelCacheFiller(this.model, this.fonts).fillCache();
-        this.removeRedundant();
-        this.modelManipulator.raiseFontListChanged(this.fontInfoCache);
-    }
-    addAndLoad() {
-        this.fonts.fonts.forEach(font => {
-            let newFont = this.fontInfoCache.getItemByName(font.name);
-            if (!newFont)
-                newFont = this.fontInfoCache.addFont(font.name, font.fontFamily);
-            else
-                newFont.cssString = FontInfoCache.correctCssString(font.fontFamily);
-            const addControlFont = (uri, desc) => {
-                const controlFont = this.controlFontsCache.addFont(new ControlFont(font.fontFamily, desc));
-                controlFont.sourceUrls.unshift(uri);
-                const controlFontType = new class_flag.Flag();
-                controlFontType.set(ControlFontType.Bold, controlFont.descriptors.msWordBold());
-                controlFontType.set(ControlFontType.Italic, controlFont.descriptors.msWordItalic());
-                newFont.controlFontMap[controlFontType.getValue()] = controlFont.cacheKey;
-            };
-            if (font.regularFontUri)
-                addControlFont(font.regularFontUri, FontFaceDescriptors.create({}));
-            if (font.boldFontUri)
-                addControlFont(font.boldFontUri, FontFaceDescriptors.create({ weight: 'bold' }));
-            if (font.italicFontUri)
-                addControlFont(font.italicFontUri, FontFaceDescriptors.create({ style: 'italic' }));
-            if (font.boldItalicFontUri)
-                addControlFont(font.boldItalicFontUri, FontFaceDescriptors.create({ weight: 'bold', style: 'italic' }));
-            if (font.googleFontsResponse)
-                new GoogleFontsApi(this.controlFontsCache, [newFont]).parseResponce(font.googleFontsResponse);
-            else if (font.useGoogleFonts)
-                new GoogleFontsApi(this.controlFontsCache, [newFont]).loadControlFonts(_createdFonts => { });
-        });
-    }
-    removeRedundant() {
-        if (this.fonts.limitedFonts) {
-            const map = {};
-            this.fonts.fonts.forEach(f => map[f.name] = f);
-            this.fontInfoCache.removeItems(font => !map[font.name]);
-        }
-    }
-}
-
 ;// CONCATENATED MODULE: ./src/client/commands/new-document-command.ts
 
 
@@ -141092,8 +141464,8 @@ class DialogManager {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_type.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_type.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141195,8 +141567,8 @@ const isEvent = function(object) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/type.js
 /**
  * DevExtreme (esm/core/utils/type.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141206,8 +141578,8 @@ const isEvent = function(object) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_extend.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_extend.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141265,8 +141637,8 @@ const extend = function(target) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/extend.js
 /**
  * DevExtreme (esm/core/utils/extend.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141276,8 +141648,8 @@ const extend = function(target) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_string.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_string.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141352,8 +141724,8 @@ const isEmpty = function() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/string.js
 /**
  * DevExtreme (esm/core/utils/string.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141363,20 +141735,20 @@ const isEmpty = function() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/version.js
 /**
  * DevExtreme (esm/core/version.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
  */
-const version = "25.1.1";
-const fullVersion = "25.1.1";
+const version = "25.1.3";
+const fullVersion = "25.1.3";
 
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_console.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_console.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141416,8 +141788,8 @@ const debug = function() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_error.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_error.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141488,8 +141860,8 @@ function error(baseErrors, errors) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/error.js
 /**
  * DevExtreme (esm/core/utils/error.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141500,8 +141872,8 @@ function error(baseErrors, errors) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/m_errors.js
 /**
  * DevExtreme (esm/__internal/core/m_errors.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141538,6 +141910,7 @@ function error(baseErrors, errors) {
     E0110: "Unknown validation group is detected",
     E0120: "Adapter for a DevExpressValidator component cannot be configured",
     E0121: "The 'customItem' parameter of the 'onCustomItemCreating' function is empty or contains invalid data. Assign a custom object or a Promise that is resolved after the item is created.",
+    E0122: "AIIntegration: The sendRequest method is missing.",
     W0000: "'{0}' is deprecated in {1}. {2}",
     W0001: "{0} - '{1}' option is deprecated in {2}. {3}",
     W0002: "{0} - '{1}' method is deprecated in {2}. {3}",
@@ -141567,8 +141940,8 @@ function error(baseErrors, errors) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/errors.js
 /**
  * DevExtreme (esm/core/errors.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141579,8 +141952,8 @@ function error(baseErrors, errors) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/m_class.js
 /**
  * DevExtreme (esm/__internal/core/m_class.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141713,8 +142086,8 @@ classImpl.abstract = m_class_abstract;
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/class.js
 /**
  * DevExtreme (esm/core/class.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141725,8 +142098,8 @@ classImpl.abstract = m_class_abstract;
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_iterator.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_iterator.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141775,8 +142148,8 @@ const reverseEach = (array, callback) => {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_dependency_injector.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_dependency_injector.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141825,8 +142198,8 @@ function injector(object) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/dependency_injector.js
 /**
  * DevExtreme (esm/core/utils/dependency_injector.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141837,8 +142210,8 @@ function injector(object) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/ldml/date.formatter.js
 /**
  * DevExtreme (esm/common/core/localization/ldml/date.formatter.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141991,8 +142364,8 @@ function _extends() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/m_config.js
 /**
  * DevExtreme (esm/__internal/core/m_config.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142067,8 +142440,8 @@ if ("undefined" !== typeof DevExpress && DevExpress.config) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/config.js
 /**
  * DevExtreme (esm/common/config.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142079,8 +142452,8 @@ if ("undefined" !== typeof DevExpress && DevExpress.config) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/m_guid.js
 /**
  * DevExtreme (esm/__internal/core/m_guid.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142122,8 +142495,8 @@ const Guid = core_class.inherit({
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/guid.js
 /**
  * DevExtreme (esm/common/guid.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142134,8 +142507,8 @@ const Guid = core_class.inherit({
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/templates/m_template_engine_registry.js
 /**
  * DevExtreme (esm/__internal/core/templates/m_template_engine_registry.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142164,8 +142537,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/templates/template_engine_registry.js
 /**
  * DevExtreme (esm/core/templates/template_engine_registry.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142175,8 +142548,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/m_set_template_engine.js
 /**
  * DevExtreme (esm/__internal/core/m_set_template_engine.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142186,8 +142559,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/set_template_engine.js
 /**
  * DevExtreme (esm/common/set_template_engine.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142198,8 +142571,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common.js
 /**
  * DevExtreme (esm/common.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142212,8 +142585,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/config.js
 /**
  * DevExtreme (esm/core/config.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142224,8 +142597,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/guid.js
 /**
  * DevExtreme (esm/core/guid.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142236,8 +142609,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/console.js
 /**
  * DevExtreme (esm/core/utils/console.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142247,8 +142620,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_variable_wrapper.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_variable_wrapper.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142277,8 +142650,8 @@ const m_variable_wrapper_variableWrapper = dependency_injector({
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/variable_wrapper.js
 /**
  * DevExtreme (esm/core/utils/variable_wrapper.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142289,8 +142662,8 @@ const m_variable_wrapper_variableWrapper = dependency_injector({
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_object.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_object.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142390,8 +142763,8 @@ const m_object_deepExtendArraySafe = function(target, changes, extendComplexObje
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/object.js
 /**
  * DevExtreme (esm/core/utils/object.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142401,8 +142774,8 @@ const m_object_deepExtendArraySafe = function(target, changes, extendComplexObje
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_data.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_data.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142598,8 +142971,8 @@ const toComparable = function(value, caseSensitive) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/data.js
 /**
  * DevExtreme (esm/core/utils/data.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142609,8 +142982,8 @@ const toComparable = function(value, caseSensitive) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_callbacks.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_callbacks.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142705,8 +143078,8 @@ const Callbacks = function(options) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/callbacks.js
 /**
  * DevExtreme (esm/core/utils/callbacks.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142717,8 +143090,8 @@ const Callbacks = function(options) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_deferred.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_deferred.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142883,8 +143256,8 @@ function when() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/deferred.js
 /**
  * DevExtreme (esm/core/utils/deferred.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142894,8 +143267,8 @@ function when() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_common.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_common.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143190,8 +143563,8 @@ const equalByValue = function(value1, value2) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/common.js
 /**
  * DevExtreme (esm/core/utils/common.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143201,8 +143574,8 @@ const equalByValue = function(value1, value2) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_math.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_math.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143371,8 +143744,8 @@ function roundFloatPart(value) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/math.js
 /**
  * DevExtreme (esm/core/utils/math.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143382,8 +143755,8 @@ function roundFloatPart(value) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/utils.js
 /**
  * DevExtreme (esm/common/core/localization/utils.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143410,8 +143783,8 @@ function toFixed(value, precision) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/ldml/number.js
 /**
  * DevExtreme (esm/common/core/localization/ldml/number.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143652,8 +144025,8 @@ function getFormat(formatter) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/currency.js
 /**
  * DevExtreme (esm/common/core/localization/currency.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143685,8 +144058,8 @@ function getFormat(formatter) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/cldr-data/parent_locales.js
 /**
  * DevExtreme (esm/common/core/localization/cldr-data/parent_locales.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143871,8 +144244,8 @@ function getFormat(formatter) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/parentLocale.js
 /**
  * DevExtreme (esm/common/core/localization/parentLocale.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143889,8 +144262,8 @@ const PARENT_LOCALE_SEPARATOR = "-";
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/core.js
 /**
  * DevExtreme (esm/common/core/localization/core.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143931,8 +144304,8 @@ const DEFAULT_LOCALE = "en";
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/open_xml_currency_format.js
 /**
  * DevExtreme (esm/common/core/localization/open_xml_currency_format.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143974,8 +144347,8 @@ const DEFAULT_LOCALE = "en";
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/cldr-data/accounting_formats.js
 /**
  * DevExtreme (esm/common/core/localization/cldr-data/accounting_formats.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144561,8 +144934,8 @@ const DEFAULT_LOCALE = "en";
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/intl/number.js
 /**
  * DevExtreme (esm/common/core/localization/intl/number.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144683,8 +145056,8 @@ const getCurrencyFormatter = currency => new Intl.NumberFormat(core.locale(), {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/number.js
 /**
  * DevExtreme (esm/common/core/localization/number.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144991,8 +145364,8 @@ if (hasIntl) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/ldml/date.format.js
 /**
  * DevExtreme (esm/common/core/localization/ldml/date.format.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145189,8 +145562,8 @@ const date_format_getFormat = function(formatter) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/ldml/date.parser.js
 /**
  * DevExtreme (esm/common/core/localization/ldml/date.parser.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145508,8 +145881,8 @@ const getParser = function(format, dateParts) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/default_date_names.js
 /**
  * DevExtreme (esm/common/core/localization/default_date_names.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145545,8 +145918,8 @@ const cutCaptions = (captions, format) => {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/cldr-data/first_day_of_week_data.js
 /**
  * DevExtreme (esm/common/core/localization/cldr-data/first_day_of_week_data.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145745,8 +146118,8 @@ const cutCaptions = (captions, format) => {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/intl/date.js
 /**
  * DevExtreme (esm/common/core/localization/intl/date.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -146063,8 +146436,8 @@ const monthNameStrategies = {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/date.js
 /**
  * DevExtreme (esm/common/core/localization/date.js)
- * Version: 25.1.1-alpha
- * Build date: Wed Apr 02 2025
+ * Version: 25.1.3
+ * Build date: Wed Jun 25 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -147306,7 +147679,7 @@ class ClientRichEdit {
         this.contextMenuSettings = settings.contextMenuSettings;
         this.fullScreenHelper = new FullScreenHelper(element);
         if (true)
-            external_DevExpress_config_default()(JSON.parse(atob('eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaVJWTTBSVlk0YmxKaVpYVk9OVGRWVEdSbFlVeHhZeUlLZlE9PS5MN1o0YXlNMTRnUWtScExSaEt6MGZSMDU5d1E5cWhhMi9ESThnRG83SEJxbFM2L1BMNVRtTmRrTVRzMmdUL3oyUFVQZDgyZGRMM0dsbjZiQUM0aXB4cUI0Y1ozT1FkZjhVc1pmMm9TOCs5SnliZGdCS1diYnFseXdEMUVFbkwwNmV0eWdtQT09In0=')));
+            external_DevExpress_config_default()(JSON.parse(atob('eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaVZqSlJjRkZ0U2xaWVYzazJUbVY0YTNFNVdHczVieUlLZlE9PS5EMTNKeDFkWmJlWFE0bGVWQ05XZnk5U2FLeWFHbmxMOE1xYkF2YzloQ3FVZTlBajJWYzJUS2RaU01RR05xVkVkSjMrTWZQKzQrQTBqMFhCSGxEczdEV2xpWFlNK01EMEVCaEJVQ0JTVzVmeWRGSzhyOGpEMDRzV2ZKYS9CTDRFTGdLOWZpZz09In0=')));
         this.prepareElement(element, settings);
         this.initDefaultFontsAndStyles();
         this.initBars(settings.ribbon, settings.fonts);
@@ -147490,7 +147863,7 @@ class ClientRichEdit {
             const ribbonBar = new ClientRibbonBar(this, this.element, ribbon, fonts);
             this.barHolder.ribbon = ribbonBar;
             if (this.core) {
-                this.core.modelManager.modelManipulator.modelListeners.push(this.barHolder.ribbon);
+                this.core.modelManager.modelManipulator.addModelListener(this.barHolder.ribbon);
                 this.core.selection.onChanged.add(this.barHolder.ribbon);
                 ribbonBar.initialize(this.core);
             }
@@ -148452,9 +148825,6 @@ function executeApiCommandCore(commandManager, commandId, parameter) {
                 break;
             }
             ;
-        case ViewTabCommandId.ToggleAllowZoom:
-            parameter = undefined;
-            break;
         case HeaderAndFooterTabCommandId.GoToPageHeader:
             parameter = undefined;
             break;
@@ -149767,11 +150137,11 @@ class RichEditPublic {
         command.execute(true, type);
     }
     get readOnly() {
-        return this._native.core.readOnly == ReadOnlyMode.Persistent;
+        return this._native.core.readOnly === ReadOnlyMode.Persistent;
     }
     set readOnly(value) {
         if (this.readOnly != value) {
-            this._native.core.readOnly = value ? ReadOnlyMode.Persistent : ReadOnlyMode.None;
+            this._native.core.setPersistentReadOnly(value);
             this._native.core.barHolder.updateItemsState();
             this._native.core.horizontalRulerControl.update();
             this._native.core.beginUpdate();