devexpress-richedit 25.1.2-beta → 25.1.4-build-25191-0102

package/dist/dx.richedit.js

@@ -1,6 +1,6 @@
 /**
 * DevExpress WebRichEdit (dx.richedit.js)
-* Version: 25.1.2
+* Version: 25.1.4
 * 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 {
@@ -16431,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; }
@@ -16443,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;
     }
@@ -16465,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))
@@ -19599,6 +19616,8 @@ class StyleBase {
 
 
 
+
+
 class ParagraphStyle extends StyleBase {
     constructor(styleName, localizedName, deleted, hidden, semihidden, isDefault, maskedCharacterProperties, maskedParagraphProperties, tabs, autoUpdate, numberingListIndex, listLevelIndex, base64EncodedImage, id) {
         super(styleName, localizedName, deleted, hidden, semihidden, isDefault, base64EncodedImage, id);
@@ -19710,6 +19729,7 @@ class TabInfoBase {
         this.deleted = deleted;
         this.isDefault = isDefault;
     }
+    get isLeftAlignment() { return utils_enum/* EnumUtils */.Y.isAnyOf(this.alignment, TabAlign.Left, TabAlign.Numbering); }
     equals(obj) {
         if (!obj)
             return false;
@@ -22966,15 +22986,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)
@@ -34176,7 +34197,7 @@ class FieldsWaitingForUpdate {
                     }
                     if (!fieldParser.update(response)) {
                         someFieldInCurrentInfoNotUpdated = true;
-                        info.parsers.push(fieldParser);
+                        info.parsers.unshift(fieldParser);
                     }
                     else
                         fieldParser.destructor();
@@ -36105,7 +36126,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)
     ]);
@@ -36125,31 +36146,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)
     ]);
@@ -40510,7 +40527,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;
@@ -40520,7 +40537,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();
         }
@@ -43204,7 +43221,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));
             });
         }
     }
@@ -43219,7 +43236,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;
@@ -54152,8 +54169,8 @@ class ListLevelDisplayTextHelper {
     static getTextRange(placeholderIndices, startPlaceHolderIndex, text) {
         var index = placeholderIndices[startPlaceHolderIndex] + 1;
         var result = text.substr(index, placeholderIndices[startPlaceHolderIndex + 1] - index);
-        result = result.replace("{", "{{");
-        result = result.replace("}", "}}");
+        result = result.replace(/{/g, "{{");
+        result = result.replace(/}/g, "}}");
         return result;
     }
 }
@@ -65678,13 +65695,14 @@ class ImportedTextRunInfo extends RunInfo {
 }
 ImportedTextRunInfo.tabRegex = new RegExp(RichUtils.specialCharacters.NonBreakingSpace + "{1,}", "gi");
 class ImportedParagraphListInfo {
-    constructor(listIndex, listLevel, listFormat, listType, displayFormatString, maskedCharacterProperties) {
+    constructor(listIndex, listLevel, listFormat, listType, displayFormatString, maskedCharacterProperties, newStart = 1) {
         this.listIndex = listIndex;
         this.listLevel = listLevel;
         this.listFormat = listFormat;
         this.listType = listType;
         this.displayFormatString = displayFormatString;
         this.maskedCharacterProperties = maskedCharacterProperties;
+        this.newStart = newStart;
     }
 }
 class ImportedParagraphRunInfo extends RunInfo {
@@ -66062,6 +66080,10 @@ class HtmlModelInserter {
         if (listInfo.displayFormatString) {
             modelManipulator.numberingList.listLevelProperties.displayFormatString.setValue(model, false, targetListIndex, listLevelIndex, listInfo.displayFormatString);
         }
+        if (listInfo.newStart) {
+            modelManipulator.numberingList.setIOverrideListLevelNewStart(numberingListIndex, listLevelIndex, listInfo.newStart);
+            modelManipulator.numberingList.setIOverrideListLevelOverrideStart(numberingListIndex, listLevelIndex, true);
+        }
         if (listInfo.maskedCharacterProperties) {
             listLevel.setCharacterProperties(listInfo.maskedCharacterProperties);
             listLevel.onCharacterPropertiesChanged();
@@ -66639,7 +66661,8 @@ class HtmlListTagImporterBase extends HtmlTagImporterBase {
         }
         const listFormat = ParagraphListPropertiesUtils.getListType(this.element);
         const displayFormat = ParagraphListPropertiesUtils.importDisplayFormatStringByParentListFormat(listFormat, parentList === null || parentList === void 0 ? void 0 : parentList.listFormat, listLevel);
-        this.importer.listInfos.push(new ImportedParagraphListInfo(listIndex, listLevel, listFormat, listFormat == NumberingFormat.Bullet ? numbering_list_NumberingType.Bullet : numbering_list_NumberingType.MultiLevel, displayFormat, null));
+        const startIndex = parseInt(this.element.getAttribute('start'));
+        this.importer.listInfos.push(new ImportedParagraphListInfo(listIndex, listLevel, listFormat, listFormat == NumberingFormat.Bullet ? numbering_list_NumberingType.Bullet : numbering_list_NumberingType.MultiLevel, displayFormat, null, startIndex));
     }
     isImportChildren() {
         return true;
@@ -67734,7 +67757,6 @@ class HtmlImporter {
     ;
     get currElementChildren() { return utils_list.ListUtils.last(this.levelInfo).childElements; }
     ;
-    get prevLevelInfo() { return this.levelInfo[this.levelInfo.length - 2]; }
     get currLevelInfo() { return utils_list.ListUtils.last(this.levelInfo); }
     get currListItemLevelInfo() { return utils_list.ListUtils.reverseElementBy(this.levelInfo, (levelInfo) => { var _a; return ((_a = levelInfo.tagImporter) === null || _a === void 0 ? void 0 : _a.elementTag()) === 'LI'; }); }
     get currListInfo() {
@@ -67967,7 +67989,7 @@ class HtmlImporter {
         html = html.replace(/<o:[pP][^>]*>\s*<\/o:[pP]>/gi, '');
         html = html.replace(/<o:[pP][^>]*>.*?<\/o:[pP]>/gi, '&nbsp;');
         html = html.replace(/<st1:.*?>/gi, '');
-        html = html.replace(/<\!--[\s\S]*?-->/g, '');
+        html = html.replace(/<!--[\s\S]*?(-->|$)/g, '');
         html = html.replace(/\s*style="\s*"/gi, '');
         html = html.replace(/style=""/ig, "");
         html = html.replace(/style=''/ig, "");
@@ -68008,7 +68030,7 @@ class HtmlImporter {
         html = html.replace(/\n/gi, RichUtils.specialCharacters.LineBreak);
         html = html.replace(/(<\/(?!(p)+)(\s*[^>]*)?>)<\/td>/gi, '$1<p>&nbsp;</p></td>');
         html = html.replace(/(<\/(?!(p)+)(\s*[^>]*)?>)<\/th>/gi, '$1<p>&nbsp;</p></th>');
-        html = html.replace(/<script(\s[^>]*)?>[\s\S]*?<\/script>/gi, '');
+        html = html.replace(/<script\b[^>]*>[\s\S]*?(<\/script\b[^>]*>|$)/gi, '');
         html = html.replace(/<u>([\s\S]*?)<\/u>/gi, '<span style="text-decoration: underline">$1</span>');
         html = html.replace(/<s>([\s\S]*?)<\/s>/gi, '<span style="text-decoration: line-through">$1</span>');
         html = html.replace(/<\/([^\s>]+)(\s[^>]*)?><br><\/([^\s>]+)(\s[^>]*)?>/gi, '');
@@ -68631,7 +68653,7 @@ class HtmlExporter {
                         .configure((el) => {
                         el.setAttribute('border', '1');
                         el.style.cssText = 'border-width: 0px; border-collapse: collapse; border-spacing: 0px;';
-                        el.setAttribute('id', guidLabel.replace("id=\"", "").replace("\"", ""));
+                        el.setAttribute('id', guidLabel.replace(/id="/g, "").replace(/"/g, ""));
                     })
                         .startChild('tbody')
                         .startChild('tr')
@@ -68828,17 +68850,26 @@ class HtmlExporter {
                 });
                 if (!list) {
                     const parentList = (previousList === null || previousList === void 0 ? void 0 : previousList.numberingListIndex) === numberingListIndex ? previousList : null;
-                    list = { parentList, numberingListIndex, listLevelIndex, start, end };
+                    list = { parentList, numberingListIndex, listLevelIndex, start, end, intervals: [], paragraphsCount: 0 };
                     listsInInterval.push(list);
                 }
+                list.paragraphsCount++;
                 previousList = list;
-                do {
-                    list.end = end;
-                } while (list = list.parentList);
+                this.updateListIntervals(list, start, end);
             }
         }
         return listsInInterval;
     }
+    updateListIntervals(list, start, end) {
+        list.end = end;
+        const lastInterval = list.intervals.at(-1);
+        if (lastInterval && lastInterval.end === start)
+            lastInterval.end = end;
+        else
+            list.intervals.push({ start, end, listStartValue: list.paragraphsCount });
+        if (list.parentList)
+            this.updateListIntervals(list.parentList, start, end);
+    }
     addParentTableRecursively(model, builder, parentCell, paragraphStartPosition) {
         const parentRow = parentCell.parentRow;
         const parentTable = parentRow.parentTable;
@@ -68876,51 +68907,65 @@ class HtmlExporter {
     startList(model, subDocument, interval, builder, lists, position) {
         if (!lists.length)
             return;
-        let listIndex = lists.findIndex((list) => list.start === position);
-        if (listIndex < 0 && position === interval.start) {
+        const listsToStart = lists.filter(list => list.intervals.some(interval => interval.start === position));
+        if (!listsToStart.length && position === interval.start) {
             const firstParagraph = subDocument.getParagraphByPosition(position);
             if (firstParagraph.getNumberingListIndex() === lists[0].numberingListIndex)
-                listIndex = 0;
-        }
-        if (listIndex > -1) {
-            const numberingList = model.numberingLists[lists[listIndex].numberingListIndex];
-            const numberingListFormat = numberingList.levels[lists[listIndex].listLevelIndex].getListLevelProperties().format;
-            const numberingListType = numberingList.getListType();
-            let listFormatType = "";
-            switch (numberingListFormat) {
+                listsToStart.push(lists[0]);
+        }
+        for (const list of listsToStart) {
+            const numberingList = model.numberingLists[list.numberingListIndex];
+            const level = numberingList.levels[list.listLevelIndex];
+            const format = level.getListLevelProperties().format;
+            const listType = numberingList.getListType();
+            const levelStart = level.getNewStart();
+            const intervalStart = list.intervals.find(interval => interval.start === position).listStartValue;
+            const listStart = Math.max(levelStart, intervalStart);
+            let listStyleType = "";
+            switch (format) {
                 case NumberingFormat.Bullet:
-                    listFormatType = "disc";
+                    listStyleType = "disc";
                     break;
                 case NumberingFormat.Decimal:
-                    listFormatType = "decimal";
+                    listStyleType = "decimal";
                     break;
                 case NumberingFormat.LowerLetter:
-                    listFormatType = "lower-alpha";
+                    listStyleType = "lower-alpha";
                     break;
                 case NumberingFormat.UpperLetter:
-                    listFormatType = "upper-alpha";
+                    listStyleType = "upper-alpha";
                     break;
                 case NumberingFormat.LowerRoman:
-                    listFormatType = "lower-roman";
+                    listStyleType = "lower-roman";
                     break;
                 case NumberingFormat.UpperRoman:
-                    listFormatType = "upper-roman";
+                    listStyleType = "upper-roman";
                     break;
                 default:
                     break;
             }
             builder
-                .startChild(numberingListType !== numbering_list_NumberingType.Bullet ? "ol" : "ul")
-                .configure((e) => e.style.cssText = "list-style-type:" + listFormatType);
+                .startChild(listType !== numbering_list_NumberingType.Bullet ? "ol" : "ul")
+                .configure((e) => {
+                e.style.cssText = "list-style-type:" + listStyleType;
+                if (listStart > 1)
+                    e.setAttribute("start", listStart.toString());
+            });
         }
     }
     endList(model, builder, lists, endPosition) {
         for (let i = lists.length - 1; i >= 0; i--) {
-            if (lists[i].end === endPosition) {
-                const listType = model.numberingLists[lists[i].numberingListIndex].getListType();
-                lists.splice(i, 1);
-                builder.endChild(listType != numbering_list_NumberingType.Bullet ? "ol" : "ul");
+            const list = lists[i];
+            for (let j = list.intervals.length - 1; j >= 0; j--) {
+                const interval = list.intervals[j];
+                if (interval.end === endPosition) {
+                    const listType = model.numberingLists[list.numberingListIndex].getListType();
+                    builder.endChild(listType !== numbering_list_NumberingType.Bullet ? "ol" : "ul");
+                    list.intervals.splice(j, 1);
+                }
             }
+            if (list.intervals.length === 0)
+                lists.splice(i, 1);
         }
     }
     getHtmlText(text) {
@@ -70761,10 +70806,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);
@@ -70830,11 +70969,17 @@ class DocumentLayout {
         return this.pages.find((page) => !!page.mainSubDocumentPageAreas[subDocumentId] || !!page.otherPageAreas[subDocumentId]);
     }
     findPageIndexByOffsetY(offsetY, sizeInfo) {
-        return Math.max(0, search.SearchUtils.normedInterpolationIndexOf(this.pages, (p) => sizeInfo.getPageOffsetY(p), offsetY));
+        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
+
+
+
+
 var BorderLineStyleApi;
 (function (BorderLineStyleApi) {
     BorderLineStyleApi[BorderLineStyleApi["Nil"] = -1] = "Nil";
@@ -79860,7 +80005,7 @@ class TextDestination extends ElementDestination {
         return true;
     }
     replaceLineBreakOnSpace(text) {
-        return text.replace('\n', ' ');
+        return text.replace(/\n/g, ' ');
     }
 }
 
@@ -82682,7 +82827,7 @@ class ListLevelFormatStringDestination extends ListLevelElementDestination {
     }
     convertFormatString(value) {
         const regex = new RegExp(/%\d/);
-        let result = value.replace('{', '{{').replace('}', '}}');
+        let result = value.replace(/{/g, '{{').replace(/}/g, '}}');
         let match = result.match(regex);
         if (match) {
             do {
@@ -84217,6 +84362,7 @@ class ChangeRectangularObjectLockAspectRatioHistoryItem extends interval_based_h
 }
 
 ;// CONCATENATED MODULE: ./src/client/model-api/images/image-enums.ts
+
 var FloatingObjectHorizontalPositionTypeApi;
 (function (FloatingObjectHorizontalPositionTypeApi) {
     FloatingObjectHorizontalPositionTypeApi[FloatingObjectHorizontalPositionTypeApi["Aligned"] = 0] = "Aligned";
@@ -84850,7 +84996,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();
@@ -85880,6 +86026,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
 
 
@@ -85890,6 +86221,7 @@ class sub_documents_collection_SubDocumentCollection extends Collection {
 
 
 
+
 class RichEditDocumentApi {
     constructor(processor) {
         this._processor = processor;
@@ -85988,6 +86320,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();
     }
@@ -86418,7 +86751,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
@@ -91315,9 +91647,9 @@ class RelationsBaseExporter extends ExporterBaseWithRootElement {
     urlEncodeAsciiSpecialSymbols(url) {
         if (url) {
             if (url.indexOf(' ') >= 0)
-                url = url.replace(' ', '%20');
+                url = url.replace(/ /g, '%20');
             if (url.indexOf('\'') >= 0)
-                url = url.replace("\'", '%27');
+                url = url.replace(/'/g, '%27');
         }
         return url;
     }
@@ -92950,7 +93282,6 @@ var LayoutRowStateFlags;
     LayoutRowStateFlags[LayoutRowStateFlags["DocumentEnd"] = 16] = "DocumentEnd";
     LayoutRowStateFlags[LayoutRowStateFlags["CellTableEnd"] = 64] = "CellTableEnd";
     LayoutRowStateFlags[LayoutRowStateFlags["PageBreakBefore"] = 128] = "PageBreakBefore";
-    LayoutRowStateFlags[LayoutRowStateFlags["InfinityWidth"] = 256] = "InfinityWidth";
 })(LayoutRowStateFlags || (LayoutRowStateFlags = {}));
 class layout_row_LayoutRow extends rectangle.Rectangle {
     get hasEffectToPageHeight() { return this.boxes.length != 1 || !this.boxes[0].isSectionBreakBox; }
@@ -94170,7 +94501,7 @@ class RowFormatterResult {
             return;
         this.rowFormatter.tabInfo.shiftBoxesAfterLastTab();
         const dontJustifyLinesEndingInSoftLineBreak = this.rowFormatter.manager.model.compatibilitySettings.dontJustifyLinesEndingInSoftLineBreak;
-        if (!this.row.flags.get(LayoutRowStateFlags.InfinityWidth))
+        if (!this.rowFormatter.rowSizesManager.isInfinityWidth)
             BoxAligner.align(this.row, this.rowFormatter.paragraphProps.alignment, currLogicRowEndPos, this.rowBoxIndexStart, dontJustifyLinesEndingInSoftLineBreak);
         this.rowBoxIndexStart = this.row.boxes.length;
     }
@@ -95200,7 +95531,7 @@ class RowFormattingInfo {
         let index = 0;
         while (index < this.intervals.length) {
             const interval = this.intervals[index];
-            if (interval.start <= position && position < interval.end || position < interval.start)
+            if (position < interval.start || interval.start <= position && position < interval.end)
                 break;
             index++;
         }
@@ -95225,7 +95556,7 @@ class RowFormattingInfo {
     calcIntersectObjects(height) {
         const initRect = new rectangle.Rectangle(this.outerHorizontalRowContentBounds.start, this.minY, this.outerHorizontalRowContentBounds.length, height);
         return utils_list.ListUtils.reducedMap(this.boundsOfAnchoredOblectsOnThisColumn, (objInfo) => {
-            if (this.tableCell !== objInfo.cell)
+            if (this.tableCell !== objInfo.cell || this.isInfinityWidth)
                 return null;
             const rect = rectangle.Rectangle.getNonCollapsedIntersection(initRect, objInfo.bounds);
             if (!rect)
@@ -95528,6 +95859,8 @@ class RowSizesManager {
         this.rowFormattingInfo = new RowFormattingInfo(minY, this.heightCalculator.currState.getFullRowHeight(), outerHorizontalRowContentBounds, boundsOfAnchoredOblectsOnThisColumn, tableCell);
         this.rowFormattingInfo.calculate();
     }
+    get isInfinityWidth() { return this.rowFormattingInfo.isInfinityWidth; }
+    set isInfinityWidth(value) { this.rowFormattingInfo.isInfinityWidth = value; }
     addNumberingListBoxes() {
         const { paragraph, result: { paragraphIndex }, numberingListCountersManager, manager: formatterManager } = this.rowFormatter;
         const counters = numberingListCountersManager.calculateCounters(paragraphIndex);
@@ -95820,7 +96153,7 @@ class RowBaseFormatterState {
             return;
         if (!this.rowFormatter.rowSizesManager.addNumberingBoxes())
             return;
-        if (this.rowFormatter.tabInfo.addTabBox())
+        if (this.rowFormatter.tabInfo.tryAddTabBox())
             this.rowFormatter.setState(TextRowFormatterState.Base);
         else
             this.rowFormatter.finishRow();
@@ -95903,7 +96236,6 @@ class RowEndedWithPageBreakState extends RowEndedWithParagraphMarkFormatterState
 
 
 
-
 class RowTabInfo {
     get row() {
         return this.rowFormatter.row;
@@ -95949,52 +96281,46 @@ class RowTabInfo {
         }
         this.restart();
     }
-    addTabBox() {
-        const box = this.rowFormatter.currBox;
+    tryAddTabBox() {
         this.shiftBoxesAfterLastTab();
         let tabPosition = this.getNextCustomTabPosition(this.currInterval.startOfFreeSpace);
-        const isCustomNonLeftTabPosition = tabPosition && !utils_enum/* EnumUtils */.Y.isAnyOf(tabPosition.alignment, TabAlign.Left, TabAlign.Numbering);
+        const isCustomNonLeftTabPosition = tabPosition && !tabPosition.isLeftAlignment;
         let tabXPosRelativePage = tabPosition ? tabPosition.position : this.getNextDefaultTabPosition(this.currInterval.startOfFreeSpace);
         if (tabXPosRelativePage > this.currInterval.end) {
-            let ind = this.rowFormatter.rowSizesManager.rowFormattingInfo.indexOfIntervalContainsPositon(tabXPosRelativePage);
-            if (ind != this.rowFormatter.rowSizesManager.rowFormattingInfo.currIndex) {
-                if (isCustomNonLeftTabPosition)
-                    tabXPosRelativePage = this.currInterval.end;
-                else {
-                    this.rowFormatter.rowSizesManager.finishLogicalRow(ind, this.currInterval.end);
-                    tabPosition = this.getNextCustomTabPosition(this.currInterval.startOfFreeSpace);
-                    tabXPosRelativePage = tabPosition ? tabPosition.position : this.getNextDefaultTabPosition(this.currInterval.startOfFreeSpace);
-                }
+            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.isInfinityWidth = true;
+                this.rowFormatter.rowSizesManager.rowFormattingInfo.recalculate(interval);
+                this.row.width = Number.MAX_SAFE_INTEGER;
+                return this.tryAddTabBox();
             }
-        }
-        box.x = this.currInterval.startOfFreeSpace;
-        box.width = !isCustomNonLeftTabPosition ? tabXPosRelativePage - box.x : 0;
-        const tabBox = box.getLayoutTabBox(tabPosition ? tabPosition.leader : TabLeaderType.None);
-        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 && 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();
-                }
-                else if (tabBox.right < this.rowFormatter.paragraphHorizontalBounds.end) {
-                    const delta = this.rowFormatter.paragraphHorizontalBounds.end - lastInterval.end;
-                    let canIncrease = !isCustomNonLeftTabPosition;
-                    if (canIncrease && this.rowFormatter.rowSizesManager.rowFormattingInfo.isFloatingIntersectRow) {
-                        canIncrease = !algorithms.IntervalAlgorithms.getIntersection(new fixed.FixedInterval(lastInterval.end, delta), utils_list.ListUtils.last(this.rowFormatter.rowSizesManager.rowFormattingInfo.busyIntervals));
+            else {
+                let ind = this.rowFormatter.rowSizesManager.rowFormattingInfo.indexOfIntervalContainsPositon(tabXPosRelativePage);
+                if (ind != this.rowFormatter.rowSizesManager.rowFormattingInfo.currIndex) {
+                    if (isCustomNonLeftTabPosition) {
+                        this.addTabBox(tabPosition, this.currInterval.end);
+                        return true;
                     }
-                    if (canIncrease) {
-                        lastInterval.end = this.rowFormatter.paragraphHorizontalBounds.end;
-                        lastInterval.avaliableWidth += delta;
-                        this.row.width += delta;
-                        return this.addTabBox();
+                    else {
+                        this.rowFormatter.rowSizesManager.finishLogicalRow(ind, this.currInterval.end);
+                        tabPosition = this.getNextCustomTabPosition(this.currInterval.startOfFreeSpace);
+                        return this.tryAddTabBox();
                     }
                 }
             }
+            const extraSpace = this.rowFormatter.paragraphHorizontalBounds.end - this.currInterval.end;
+            if (extraSpace > 0) {
+                let canIncrease = !isCustomNonLeftTabPosition;
+                if (canIncrease && this.rowFormatter.rowSizesManager.rowFormattingInfo.isFloatingIntersectRow)
+                    canIncrease = !algorithms.IntervalAlgorithms.getIntersection(new fixed.FixedInterval(this.currInterval.end, extraSpace), utils_list.ListUtils.last(this.rowFormatter.rowSizesManager.rowFormattingInfo.busyIntervals));
+                if (canIncrease) {
+                    this.currInterval.end = this.rowFormatter.paragraphHorizontalBounds.end;
+                    this.currInterval.avaliableWidth += extraSpace;
+                    this.row.width += extraSpace;
+                    return this.tryAddTabBox();
+                }
+            }
             if (!this.row.isEmpty() && !isCustomNonLeftTabPosition)
                 return false;
             if (this.rowFormatter.rowSizesManager.rowFormattingInfo.isFloatingIntersectRow && !isCustomNonLeftTabPosition) {
@@ -96002,13 +96328,20 @@ class RowTabInfo {
                 this.rowFormatter.rowSizesManager.restartAllRow(false);
                 while (utils_enum/* EnumUtils */.Y.isAnyOf(this.rowFormatter.currBox.getType(), LayoutBoxType.AnchorPicture, LayoutBoxType.AnchorTextBox))
                     this.rowFormatter.setBoxInfo(true);
-                return this.addTabBox();
+                return this.tryAddTabBox();
             }
         }
+        this.addTabBox(tabPosition, tabXPosRelativePage);
+        return true;
+    }
+    addTabBox(tabPosition, tabXPosRelativePage) {
+        const box = this.rowFormatter.currBox;
+        box.x = this.currInterval.startOfFreeSpace;
+        box.width = (!tabPosition || tabPosition.isLeftAlignment) ? tabXPosRelativePage - box.x : 0;
+        const tabBox = box.getLayoutTabBox(tabPosition ? tabPosition.leader : TabLeaderType.None);
         this.rowFormatter.rowSizesManager.addTabBox(tabBox);
         this.lastTabPosition = tabPosition ? tabPosition : new TabInfo(tabXPosRelativePage, TabAlign.Left, TabLeaderType.None, false, false);
         this.lastTabBoxIndex = this.row.boxes.length - 1;
-        return true;
     }
     calculateActualTabWidth(prevTabBox) {
         const prevTabBoxXPos = prevTabBox.x;
@@ -96092,7 +96425,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();
@@ -105547,7 +105880,6 @@ class SwitchTextBoxSubDocumentsStateHistoryItem extends history_item_HistoryItem
 
 
 
-
 class FloatingObjectMovedArgumentInner {
     constructor(subDocumentId, newPosition, pageIntervals, pageIndex, objectX, objectY) {
         this.newPosition = newPosition;
@@ -105576,7 +105908,6 @@ class FloatingObjectDragDropChangePositionCommand extends CommandBase {
             this.getFloatingObjectParentSubDocument().isEditable([new fixed.FixedInterval(specialRunInfo.getPosition(), 1)]);
     }
     executeCore(_state, options) {
-        const topInfo = this.control.viewManager.canvasManager.getScrollTopInfo();
         const runInfo = this.activeSubDocument.getRunAndIndexesByPosition(this.selection.specialRunInfo.getPosition());
         const oldRun = runInfo.run.clone();
         const oldRunPos = runInfo.getAbsoluteRunPosition();
@@ -105591,7 +105922,6 @@ class FloatingObjectDragDropChangePositionCommand extends CommandBase {
             this.changeActiveSubDocument(initialHtr, finalClickPoint);
         this.move(oldRun, oldRunPos, initialHtr, options.endPageIndex, options.finalPoint);
         this.history.endTransaction();
-        this.selection.scrollManager.setScroll(new ScrollState().byScrollInfo.setPageInfo(topInfo));
         return true;
     }
     changeActiveSubDocument(htr, point) {
@@ -108108,99 +108438,6 @@ class DimensionInfo {
     }
 }
 
-;// 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/canvas/canvas-manager.ts
 
 
@@ -108458,7 +108695,7 @@ class CanvasManager extends batch_updatable/* BatchUpdatableObject */.IS {
         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, this.sizes);
+        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) {
@@ -108747,7 +108984,7 @@ class CanvasScrollManager {
             height.clear().addLayoutSize(position.page.height);
         if (relativePosition === RelativePosition.Bottom)
             y.subtractUISize(this.sizes.getVisibleAreaHeight(false));
-        y.addUISize(canvasState.getVerticalOffset(this.sizes));
+        y.addLayoutSize(canvasState.getVerticalOffset(this.sizes));
         if (relativePosition === RelativePosition.Inside) {
             let scrollTop = this.canvas.scrollTop;
             const scrollVisibleAreaHeight = this.sizes.getVisibleAreaHeight(false);
@@ -108806,9 +109043,9 @@ class CanvasSizeInfo {
         this.setVisibleAreaSize(SizeUtils.getClientWidth(canvas), SizeUtils.getClientHeight(canvas));
     }
     getPageOffsetY(layoutPage) {
-        const pageOffsetY = layoutPage.y + (this.topSpacing + layoutPage.index * this.betweenPageSpacing);
-        return pageOffsetY * this.zoomLevelHolder.zoomLevel;
+        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;
@@ -110112,6 +110349,7 @@ class ZoomLevelChange {
 
 
 
+
 
 
 class ViewManager {
@@ -110199,9 +110437,9 @@ class ViewManager {
             const pageInfo = layoutSelection.selectionInfo.pageInfos[pageIndex];
             const item = pageInfo.oldItems[0];
             const layoutPage = this.layout.pages[pageIndex];
-            const x = layoutPage.x + this.cache[pageIndex].page.offsetLeft + item.x;
-            const y = this.sizes.getPageOffsetY(layoutPage) + item.y;
-            this.inputController.setPosition(x, 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() {
@@ -111562,7 +111800,7 @@ 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) {
+        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);
@@ -111668,7 +111906,7 @@ class InputController {
     }
     static getCopyPasteHtmlContentForEditable(html, guidLabel) {
         const builder = new HtmlBuilder();
-        const id = guidLabel.replace("id=\"", "").replace("\"", "");
+        const id = guidLabel.replace(/id="/g, "").replace(/"/g, "");
         builder
             .startChild('a')
             .configure((el) => {
@@ -112824,6 +113062,7 @@ class RulerMultiControl {
 
 
 
+
 const TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME = " table";
 var SnapTo;
 (function (SnapTo) {
@@ -112856,7 +113095,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;
@@ -113916,13 +114155,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;
@@ -117774,6 +118009,7 @@ class DxtUtils {
 }
 
 ;// CONCATENATED MODULE: ./src/client/public/commands/enum.ts
+
 var FileTabCommandId;
 (function (FileTabCommandId) {
     FileTabCommandId[FileTabCommandId["CreateDocument"] = 412] = "CreateDocument";
@@ -117934,7 +118170,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) {
@@ -123009,6 +123244,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);
@@ -123021,23 +123257,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);
@@ -123045,6 +123282,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
 
@@ -127102,7 +127354,6 @@ class DialogLayoutOptionsCommand extends ShowDialogCommandBase {
         let run = subDocument.getRunByPosition(position);
         let modelManipulator = this.modelManipulator;
         let anchorInfoManipulator = modelManipulator.floatingObject.anchorInfo;
-        const topInfo = this.control.viewManager.canvasManager.getScrollTopInfo();
         let history = this.history;
         history.beginTransaction();
         let changed = false;
@@ -127268,8 +127519,6 @@ class DialogLayoutOptionsCommand extends ShowDialogCommandBase {
             changed = true;
         }
         history.endTransaction();
-        if (topInfo)
-            this.selection.scrollManager.setScroll(new ScrollState().byScrollInfo.setPageInfo(topInfo));
         return changed;
     }
     getDialogName() {
@@ -128563,8 +128812,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)
@@ -128579,12 +128838,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;
@@ -128603,22 +128877,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;
@@ -130111,7 +130388,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);
@@ -130146,7 +130423,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;
@@ -130159,8 +130436,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));
             }
         }
@@ -130200,25 +130476,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
 
 
@@ -130427,7 +130684,6 @@ class ToggleFullScreenCommand extends CommandBase {
 ;// CONCATENATED MODULE: ./src/common/commands/layout/toggle-show-hidden-symbols-command.ts
 
 
-
 class ToggleShowHiddenSymbolsCommand extends CommandBase {
     getState() {
         return new SimpleCommandState(this.isEnabled(), this.control.innerClientProperties.showHiddenSymbols);
@@ -130439,9 +130695,7 @@ class ToggleShowHiddenSymbolsCommand extends CommandBase {
         let newValue = options.param;
         if (newValue !== this.control.innerClientProperties.showHiddenSymbols) {
             this.control.innerClientProperties.showHiddenSymbols = newValue;
-            const topInfo = this.control.viewManager.canvasManager.getScrollTopInfo();
             this.control.layoutFormatterManager.invalidator.onChangedAllLayout();
-            this.selection.scrollManager.setScroll(new ScrollState().byScrollInfo.setPageInfo(topInfo));
             return true;
         }
         return false;
@@ -136748,7 +137002,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 {
@@ -137011,7 +137265,6 @@ class UndoCommand extends CommandBase {
 
 
 
-
 
 
 class CommandManager {
@@ -137397,7 +137650,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));
     }
@@ -137658,7 +137910,6 @@ class InsertPictureCommand extends CommandBase {
 
 
 
-
 
 
 class MailMergeCommand extends CommandBase {
@@ -137761,8 +138012,10 @@ class MailMergeCommand extends CommandBase {
     replaceMergeFieldsInSubDocument(modelManager, record, lastProcessedPositionInMainSubDocument, subDoc) {
         const processField = (parser) => {
             if (parser instanceof FieldCodeParserMailMerge) {
+                parser.update(null);
                 const fieldName = parser.getMergeFieldName();
-                return RichUtils.replaceParagraphEndCharsWithLineBreak(this.getResultByFieldName(record, fieldName));
+                const simpleText = this.getResultByFieldName(record, fieldName);
+                return parser.getFormattedResult(simpleText);
             }
             return null;
         };
@@ -137825,191 +138078,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
 
 
@@ -138151,6 +138219,8 @@ class OpenDocumentCommand extends CommandBase {
             return false;
         this.beforeOpen();
         core.activeDocumentImporter.importFromFile(file, this.control.modelManager.richOptions, (documentModel, formatImagesImporter) => {
+            if (core.isDisposed)
+                return;
             core.activeDocumentImporter = null;
             this.openCore(fileName, format, documentModel, formatImagesImporter, extension);
             if (!this.suppressUpdateFields)
@@ -138158,6 +138228,8 @@ class OpenDocumentCommand extends CommandBase {
             if (callback)
                 callback(true, null);
         }, (reason) => {
+            if (core.isDisposed)
+                return;
             core.activeDocumentImporter = null;
             this.control.loadingPanelManager.loadingPanel.setVisible(false);
             NewDocumentCommand.newDocumentInner.call(this);
@@ -141426,8 +141498,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141529,8 +141601,8 @@ const isEvent = function(object) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/type.js
 /**
  * DevExtreme (esm/core/utils/type.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141540,8 +141612,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141599,8 +141671,8 @@ const extend = function(target) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/extend.js
 /**
  * DevExtreme (esm/core/utils/extend.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141610,8 +141682,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141686,8 +141758,8 @@ const isEmpty = function() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/string.js
 /**
  * DevExtreme (esm/core/utils/string.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141697,20 +141769,20 @@ const isEmpty = function() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/version.js
 /**
  * DevExtreme (esm/core/version.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 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.2";
-const fullVersion = "25.1.2";
+const version = "25.1.3";
+const fullVersion = "25.1.3.25189-0901";
 
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/utils/m_console.js
 /**
  * DevExtreme (esm/__internal/core/utils/m_console.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141750,8 +141822,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141822,8 +141894,8 @@ function error(baseErrors, errors) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/error.js
 /**
  * DevExtreme (esm/core/utils/error.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141834,8 +141906,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141902,8 +141974,8 @@ function error(baseErrors, errors) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/errors.js
 /**
  * DevExtreme (esm/core/errors.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -141914,8 +141986,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142048,8 +142120,8 @@ classImpl.abstract = m_class_abstract;
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/class.js
 /**
  * DevExtreme (esm/core/class.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142060,8 +142132,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142110,8 +142182,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142160,8 +142232,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142172,8 +142244,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142326,8 +142398,8 @@ function _extends() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/__internal/core/m_config.js
 /**
  * DevExtreme (esm/__internal/core/m_config.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142402,8 +142474,8 @@ if ("undefined" !== typeof DevExpress && DevExpress.config) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/config.js
 /**
  * DevExtreme (esm/common/config.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142414,8 +142486,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142457,8 +142529,8 @@ const Guid = core_class.inherit({
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/guid.js
 /**
  * DevExtreme (esm/common/guid.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142469,8 +142541,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142499,8 +142571,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142510,8 +142582,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142521,8 +142593,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/set_template_engine.js
 /**
  * DevExtreme (esm/common/set_template_engine.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142533,8 +142605,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common.js
 /**
  * DevExtreme (esm/common.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142547,8 +142619,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/config.js
 /**
  * DevExtreme (esm/core/config.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142559,8 +142631,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/guid.js
 /**
  * DevExtreme (esm/core/guid.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142571,8 +142643,8 @@ function getCurrentTemplateEngine() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/console.js
 /**
  * DevExtreme (esm/core/utils/console.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142582,8 +142654,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142612,8 +142684,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142624,8 +142696,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142725,8 +142797,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142736,8 +142808,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142933,8 +143005,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -142944,8 +143016,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143040,8 +143112,8 @@ const Callbacks = function(options) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/callbacks.js
 /**
  * DevExtreme (esm/core/utils/callbacks.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143052,8 +143124,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143218,8 +143290,8 @@ function when() {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/deferred.js
 /**
  * DevExtreme (esm/core/utils/deferred.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143229,8 +143301,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143525,8 +143597,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143536,8 +143608,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143706,8 +143778,8 @@ function roundFloatPart(value) {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/core/utils/math.js
 /**
  * DevExtreme (esm/core/utils/math.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143717,8 +143789,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143745,8 +143817,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -143987,8 +144059,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144020,8 +144092,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144206,8 +144278,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144224,8 +144296,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144266,8 +144338,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144309,8 +144381,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -144896,8 +144968,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145018,8 +145090,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145326,8 +145398,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145524,8 +145596,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145843,8 +145915,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -145880,8 +145952,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -146080,8 +146152,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.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -146398,8 +146470,8 @@ const monthNameStrategies = {
 ;// CONCATENATED MODULE: ./node_modules/devextreme/esm/common/core/localization/date.js
 /**
  * DevExtreme (esm/common/core/localization/date.js)
- * Version: 25.1.2-beta
- * Build date: Wed May 14 2025
+ * Version: 25.1.4-build-25189-0901
+ * Build date: Tue Jul 08 2025
  *
  * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
@@ -147641,7 +147713,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);
@@ -148787,9 +148859,6 @@ function executeApiCommandCore(commandManager, commandId, parameter) {
                 break;
             }
             ;
-        case ViewTabCommandId.ToggleAllowZoom:
-            parameter = undefined;
-            break;
         case HeaderAndFooterTabCommandId.GoToPageHeader:
             parameter = undefined;
             break;
@@ -150359,6 +150428,7 @@ var PrintModeApi;
 
 
 ;// CONCATENATED MODULE: ./src/client/public/ribbon/item-ids.ts
+
 var FileTabItemId;
 (function (FileTabItemId) {
     FileTabItemId[FileTabItemId["CreateNewDocument"] = 412] = "CreateNewDocument";