devexpress-richedit 24.1.1-alpha-24085-0102 → 24.1.3

package/lib/common/layout-formatter/formatter/base-formatter.js

@@ -222,7 +222,6 @@ export class BaseFormatter {
             if (row.tableCellInfo)
                 row.indexInColumn = index;
         });
-        this.layoutPosition.page.anchoredObjectHolder.onColumnEnd(this);
         const lastRow = createdColumn.getLastRow();
         lastRow.flags.set(LayoutRowStateFlags.ColumnEnd, true);
         if (this.manager.innerClientProperties.viewsSettings.isSimpleView) {

package/lib/common/layout-formatter/formatter/main-formatter.js

@@ -157,6 +157,7 @@ export class MainFormatter extends BaseFormatter {
         const layout = this.manager.layout;
         Log.print(LogSource.LayoutFormatter, "processStatePageEnd", () => `SubDocId: ${this.subDocument.id}, LayPos: ${LogObjToStrLayout.layoutPositionShort(this.layoutPosition)}`);
         const createdPage = this.layoutPosition.page;
+        createdPage.anchoredObjectHolder.removeOrphanedObjects(this);
         createdPage.isValid = true;
         MainFormatter.correctPageOffsets(createdPage);
         this.state = this.lastRowInfo.row.flags.get(LayoutRowStateFlags.DocumentEnd) ?

package/lib/common/layout-formatter/managers/formatter-manager.d.ts

@@ -26,12 +26,16 @@ import { RestartManager } from './restart-manager';
 export interface ILayoutFormatterManagerHolder {
     layoutFormatterManager: FormatterManager;
 }
+export declare type BrowserUtils = {
+    MacOSPlatform: boolean;
+};
 export declare class FormatterManager extends BatchUpdatableObject {
     private formatterProcessID;
     private unhideProcessID;
     private _isDocumentOpened;
     private onLayoutChangedDispatcher;
     private formatters;
+    private activeSubDocumentHolder;
     innerClientProperties: InnerClientProperties;
     model: DocumentModel;
     layout: DocumentLayout;
@@ -51,11 +55,11 @@ export declare class FormatterManager extends BatchUpdatableObject {
     mainFormatter: MainFormatter;
     bookmarksSettings: BookmarksSettings;
     documentProtectionSettings: DocumentProtectionSettings;
-    private activeSubDocumentHolder;
     floatingRestartInfoHolder: FloatingRestartInfoHolder;
+    browserUtils: BrowserUtils;
     get activeSubDocument(): SubDocument;
     get isDocumentOpened(): boolean;
-    constructor(measurer: IMeasurer, innerClientProperties: InnerClientProperties, model: DocumentModel, layout: DocumentLayout, activeSubDocumentHolder: IActiveSubDocumentHolder, bookmarksSettings: BookmarksSettings, documentProtectionSettings: DocumentProtectionSettings, controlHeightProvider: IControlHeightProvider, stringResources: StringResources, layoutChangesListeners: ILayoutChangesListener[]);
+    constructor(measurer: IMeasurer, innerClientProperties: InnerClientProperties, model: DocumentModel, layout: DocumentLayout, activeSubDocumentHolder: IActiveSubDocumentHolder, bookmarksSettings: BookmarksSettings, documentProtectionSettings: DocumentProtectionSettings, controlHeightProvider: IControlHeightProvider, stringResources: StringResources, layoutChangesListeners: ILayoutChangesListener[], browserUtils?: BrowserUtils);
     dispose(): void;
     onUpdateUnlocked(_occurredEvents: number): void;
     getLayoutFormatter(subDocumentId: number): BaseFormatter;

package/lib/common/layout-formatter/managers/formatter-manager.js

@@ -16,8 +16,9 @@ import { LayoutDependentRunCache } from '../formatter/utils/layout-dependent-cac
 import { RemoveRedundantHelper } from '../formatter/utils/remove-redundant-helper';
 import { LayoutInvalidator } from '../invalidator/layout-invalidator';
 import { RestartManager } from './restart-manager';
+import { Browser } from '@devexpress/utils/lib/browser';
 export class FormatterManager extends BatchUpdatableObject {
-    constructor(measurer, innerClientProperties, model, layout, activeSubDocumentHolder, bookmarksSettings, documentProtectionSettings, controlHeightProvider, stringResources, layoutChangesListeners) {
+    constructor(measurer, innerClientProperties, model, layout, activeSubDocumentHolder, bookmarksSettings, documentProtectionSettings, controlHeightProvider, stringResources, layoutChangesListeners, browserUtils) {
         super();
         this.formatterProcessID = null;
         this.unhideProcessID = null;
@@ -46,6 +47,7 @@ export class FormatterManager extends BatchUpdatableObject {
         this.layoutDependentRunCache = new LayoutDependentRunCache(this);
         this.restartManager = new RestartManager(this);
         this.anchoredObjectsManager = new AnchoredObjectsManager(this);
+        this.browserUtils = browserUtils !== null && browserUtils !== void 0 ? browserUtils : { MacOSPlatform: Browser.MacOSPlatform };
     }
     get activeSubDocument() { return this.activeSubDocumentHolder.activeSubDocument; }
     get isDocumentOpened() { return this._isDocumentOpened; }

package/lib/common/layout-formatter/row/size-engine/row-sizes-manager.js

@@ -9,6 +9,9 @@ import { ParagraphFirstLineIndent } from '../../../model/paragraph/paragraph-pro
 import { BoxWrap } from '../../box/box-wrap';
 import { RowFormattingInfo } from './row-formatting-info';
 import { RowHeightCalculator } from './row-height-calculator';
+import { RichUtils } from '../../../model/rich-utils';
+import { NumberingHelper } from '../../../model/numbering-lists/numbering-helper';
+import { NumberingType } from '../../../model/numbering-lists/numbering-list';
 export class RowSizesManager {
     constructor(rowFormatter, outerHorizontalRowContentBounds, minY, rowSpacingBeforeApplier, boundsOfAnchoredOblectsOnThisColumn, isFirstRowInParagraph) {
         this.rowFormatter = rowFormatter;
@@ -24,10 +27,23 @@ export class RowSizesManager {
         this.rowFormattingInfo.calculate();
     }
     addNumberingListBoxes() {
-        const paragraph = this.rowFormatter.paragraph;
-        const charProp = paragraph.getNumerationCharacterProperties();
-        this.row.numberingListBox = new LayoutNumberingListBox(charProp, charProp.getLayoutColorInfo(this.rowFormatter.manager.model.colorProvider), paragraph.getNumberingListTextCore(this.rowFormatter.numberingListCountersManager.calculateCounters(this.rowFormatter.result.paragraphIndex)), paragraph.getNumberingListSeparatorChar(), this.rowFormatter.manager.model.cache.mergedCharacterPropertiesCache, paragraph.getListLevel().getListLevelProperties().alignment, this.rowFormatter.manager.model.cache.fontInfoCache);
-        LayoutBox.initializeWithMeasurer([new BoxWrap(this.row.numberingListBox, null)], this.rowFormatter.manager.measurer, this.rowFormatter.manager.innerClientProperties.showHiddenSymbols);
+        const { paragraph, result: { paragraphIndex }, numberingListCountersManager, manager: formatterManager } = this.rowFormatter;
+        const counters = numberingListCountersManager.calculateCounters(paragraphIndex);
+        let markText = paragraph.getNumberingListTextCore(counters);
+        let markProperties = paragraph.getNumerationCharacterProperties();
+        if (formatterManager.browserUtils.MacOSPlatform &&
+            markText === RichUtils.specialCharacters.MSWordBulletMark &&
+            markProperties.fontInfo.name === 'Symbol') {
+            const listTemplate = NumberingHelper.getNumberingListTemplate(formatterManager.model, NumberingType.Bullet);
+            const level = listTemplate.levels[paragraph.getListLevelIndex()];
+            const levelFontInfo = level.getCharacterProperties().fontInfo;
+            markProperties = markProperties.clone();
+            markProperties.fontInfo = levelFontInfo.clone();
+            markProperties.fontInfo.measurer = levelFontInfo.measurer;
+            markText = level.getListLevelProperties().displayFormatString;
+        }
+        this.row.numberingListBox = new LayoutNumberingListBox(markProperties, markProperties.getLayoutColorInfo(formatterManager.model.colorProvider), markText, paragraph.getNumberingListSeparatorChar(), formatterManager.model.cache.mergedCharacterPropertiesCache, paragraph.getListLevel().getListLevelProperties().alignment, formatterManager.model.cache.fontInfoCache);
+        LayoutBox.initializeWithMeasurer([new BoxWrap(this.row.numberingListBox, null)], formatterManager.measurer, formatterManager.innerClientProperties.showHiddenSymbols);
         const boxes = [this.row.numberingListBox.textBox];
         const separatorBox = this.row.numberingListBox.separatorBox;
         if (separatorBox)

package/lib/common/measurer/measurer.js

@@ -19,7 +19,8 @@ export class Measurer {
         this.charPropsCache = charPropsCache;
     }
     clearCache() {
-        this.charPropsCache.resetSizes();
+        var _a;
+        (_a = this.charPropsCache) === null || _a === void 0 ? void 0 : _a.resetSizes();
     }
     measure(measureInfos) {
         this.htmlParts = [];

package/lib/common/model/chunk.d.ts

@@ -11,5 +11,6 @@ export declare class Chunk {
     getRunText(run: RunBase): string;
     getTextInChunk(offsetAtStartChunk: number, length: number): string;
     splitRun(runIndex: number, offset: number): void;
+    removeRun(runIndex: number): void;
     clone(subDocument: SubDocument): Chunk;
 }

package/lib/common/model/chunk.js

@@ -1,4 +1,16 @@
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
+class UndefinedRunError extends Error {
+    constructor() {
+        super();
+        this.message = 'Undefined run';
+    }
+}
+class OutOfOffsetError extends Error {
+    constructor() {
+        super();
+        this.message = 'Offset >= run.length';
+    }
+}
 export class Chunk {
     constructor(startLogPosition, textBuffer, isLast) {
         this.textBuffer = "";
@@ -19,13 +31,26 @@ export class Chunk {
     splitRun(runIndex, offset) {
         var run = this.textRuns[runIndex];
         if (!run)
-            throw new Error("Undefined run");
+            throw new UndefinedRunError();
         if (offset >= run.getLength())
-            throw new Error("Offset >= run.length");
+            throw new OutOfOffsetError();
         var newRun = run.createSimularity(run.startOffset + offset, run.getLength() - offset, run.paragraph, run.characterStyle, run.maskedCharacterProperties);
         run.setLength(offset);
         this.textRuns.splice(runIndex + 1, 0, newRun);
     }
+    removeRun(runIndex) {
+        const run = this.textRuns[runIndex];
+        if (!run)
+            throw new UndefinedRunError();
+        if (runIndex === this.textRuns.length - 1) {
+            this.textBuffer = this.textBuffer.slice(0, run.startOffset);
+            this.textRuns.pop();
+        }
+        else {
+            this.textBuffer = [this.textBuffer.slice(0, run.startOffset), this.textBuffer.slice(run.startOffset + run.getLength())].join('');
+            this.textRuns = [...this.textRuns.slice(0, runIndex), ...this.textRuns.slice(runIndex + 1)];
+        }
+    }
     clone(subDocument) {
         const result = new Chunk(subDocument.positionManager.registerPosition(this.startLogPosition.value), this.textBuffer.slice(0), this.isLast);
         result.textRuns = ListUtils.map(this.textRuns, r => r.cloneToNewSubDocument(subDocument));

package/lib/common/model/document-model.d.ts

@@ -36,6 +36,7 @@ import { DocumentLayout } from '../layout/document-layout';
 import { CacheImageInfo } from './caches/images';
 import { AnchorInfo } from './floating-objects/anchor-info';
 import { SubDocumentCollection } from './sub-document-collection';
+import { NotePosition, NoteSeparators } from './footnotes/footnote';
 export interface IModelOptions extends ICloneable<IModelOptions> {
     control: ControlOptions;
     cultureOpts: IFormattersOptions;
@@ -50,6 +51,7 @@ export declare class DocumentModel {
     pageBackColor: number;
     mirrorMargins: boolean;
     aspxIsDocumentProtectionEnabled: boolean;
+    documentEndNotePosition: NotePosition;
     sections: Section[];
     headers: HeaderSubDocumentInfo[];
     footers: FooterSubDocumentInfo[];
@@ -71,6 +73,8 @@ export declare class DocumentModel {
     numberingLists: NumberingList[];
     abstractNumberingListsIdProvider: AbstractNumberingListIdProvider;
     numberingListsIdProvider: NumberingListIdProvider;
+    footNoteSeparators: NoteSeparators;
+    endNoteSeparators: NoteSeparators;
     get subDocuments(): Record<number, SubDocument>;
     get options(): ControlOptions;
     get isDocumentProtectionEnabled(): boolean;

package/lib/common/model/document-model.js

@@ -34,10 +34,12 @@ import { FindReplaceHelper, FindReplaceState, SearchDirection } from './find-rep
 import { AnchoredPictureRun } from './runs/anchored-picture-run';
 import { InlinePictureRun } from './runs/inline-picture-run';
 import { SubDocumentCollection } from './sub-document-collection';
+import { NotePosition, NoteSeparators } from './footnotes/footnote';
 export class DocumentModel {
     constructor(modelOptions, subDocumentsIdCounter = 1) {
         this.mirrorMargins = false;
         this.aspxIsDocumentProtectionEnabled = false;
+        this.documentEndNotePosition = NotePosition.EndOfDocument;
         this.sections = [];
         this.headers = [];
         this.footers = [];
@@ -52,6 +54,8 @@ export class DocumentModel {
         this.numberingLists = [];
         this.abstractNumberingListsIdProvider = new AbstractNumberingListIdProvider(this);
         this.numberingListsIdProvider = new NumberingListIdProvider(this);
+        this.footNoteSeparators = new NoteSeparators(this);
+        this.endNoteSeparators = new NoteSeparators(this);
         this.repositoryBorderItem = new BorderInfo();
         this.compatSettings = [];
         this.subDocumentsIdCounter = -1;
@@ -69,7 +73,6 @@ export class DocumentModel {
         this.compatibilitySettings = new CompatibilitySettings();
         this.docVariables = new DocumentVariables();
     }
-    ;
     get subDocuments() {
         return this.subDocumentsCollection.filteredCollection;
     }

package/lib/common/model/enums.d.ts

@@ -2,5 +2,7 @@ export declare enum SubDocumentInfoType {
     Main = 0,
     Header = 1,
     Footer = 2,
-    TextBox = 3
+    TextBox = 3,
+    FootNote = 4,
+    EndNote = 5
 }

package/lib/common/model/enums.js

@@ -4,4 +4,6 @@ export var SubDocumentInfoType;
     SubDocumentInfoType[SubDocumentInfoType["Header"] = 1] = "Header";
     SubDocumentInfoType[SubDocumentInfoType["Footer"] = 2] = "Footer";
     SubDocumentInfoType[SubDocumentInfoType["TextBox"] = 3] = "TextBox";
+    SubDocumentInfoType[SubDocumentInfoType["FootNote"] = 4] = "FootNote";
+    SubDocumentInfoType[SubDocumentInfoType["EndNote"] = 5] = "EndNote";
 })(SubDocumentInfoType || (SubDocumentInfoType = {}));

package/lib/common/model/footnotes/footnote.d.ts

@@ -0,0 +1,46 @@
+import { ICloneable, ISupportCopyFrom } from "@devexpress/utils/lib/types";
+import { NumberingFormat } from "../numbering-lists/list-level-properties";
+import { DocumentModel } from "../document-model";
+import { SubDocument } from "../sub-document";
+export declare enum NotePosition {
+    BottomOfPage = 0,
+    BelowText = 1,
+    EndOfDocument = 2,
+    EndOfSection = 3
+}
+export declare enum NoteType {
+    Separator = 0,
+    ContinuationSeparator = 1,
+    ContinuationNotice = 2,
+    Normal = 3
+}
+export declare type NoteSeparatorTypes = NoteType.Separator | NoteType.ContinuationSeparator | NoteType.ContinuationNotice;
+export declare enum NoteNumberingRestartType {
+    Continuous = 0,
+    NewPage = 1,
+    NewSection = 2
+}
+export declare class NoteProperties implements ICloneable<NoteProperties>, ISupportCopyFrom<NoteProperties> {
+    static createDefault(): NoteProperties;
+    position: NotePosition;
+    numberingFormat: NumberingFormat;
+    numberingRestartType: NoteNumberingRestartType;
+    startingNumber: number;
+    columnCount: number;
+    copyFrom(obj: NoteProperties): void;
+    clone(): NoteProperties;
+    equals(other: NoteProperties): boolean;
+}
+export declare class NoteSeparators {
+    private model;
+    separatorId: number;
+    continuationSeparatorId: number;
+    continuationNoticeId: number;
+    constructor(model: DocumentModel);
+    get separator(): SubDocument;
+    get continuationSeparator(): SubDocument;
+    get continuationNotice(): SubDocument;
+    setSeparator(sudDocId: number, type: NoteSeparatorTypes): void;
+    getSeparator(type: NoteSeparatorTypes): SubDocument | never;
+    getSeparatos(): IterableIterator<SubDocument>;
+}

package/lib/common/model/footnotes/footnote.js

@@ -0,0 +1,100 @@
+import { NumberingFormat } from "../numbering-lists/list-level-properties";
+export var NotePosition;
+(function (NotePosition) {
+    NotePosition[NotePosition["BottomOfPage"] = 0] = "BottomOfPage";
+    NotePosition[NotePosition["BelowText"] = 1] = "BelowText";
+    NotePosition[NotePosition["EndOfDocument"] = 2] = "EndOfDocument";
+    NotePosition[NotePosition["EndOfSection"] = 3] = "EndOfSection";
+})(NotePosition || (NotePosition = {}));
+export var NoteType;
+(function (NoteType) {
+    NoteType[NoteType["Separator"] = 0] = "Separator";
+    NoteType[NoteType["ContinuationSeparator"] = 1] = "ContinuationSeparator";
+    NoteType[NoteType["ContinuationNotice"] = 2] = "ContinuationNotice";
+    NoteType[NoteType["Normal"] = 3] = "Normal";
+})(NoteType || (NoteType = {}));
+export var NoteNumberingRestartType;
+(function (NoteNumberingRestartType) {
+    NoteNumberingRestartType[NoteNumberingRestartType["Continuous"] = 0] = "Continuous";
+    NoteNumberingRestartType[NoteNumberingRestartType["NewPage"] = 1] = "NewPage";
+    NoteNumberingRestartType[NoteNumberingRestartType["NewSection"] = 2] = "NewSection";
+})(NoteNumberingRestartType || (NoteNumberingRestartType = {}));
+export class NoteProperties {
+    static createDefault() {
+        const result = new NoteProperties();
+        result.position = NotePosition.BottomOfPage;
+        result.numberingFormat = NumberingFormat.Decimal;
+        result.numberingRestartType = NoteNumberingRestartType.Continuous;
+        result.startingNumber = 1;
+        result.columnCount = 0;
+        return result;
+    }
+    copyFrom(obj) {
+        this.position = obj.position;
+        this.numberingFormat = obj.numberingFormat;
+        this.numberingRestartType = obj.numberingRestartType;
+        this.startingNumber = obj.startingNumber;
+        this.columnCount = obj.columnCount;
+    }
+    clone() {
+        const result = new NoteProperties();
+        result.copyFrom(this);
+        return result;
+    }
+    equals(other) {
+        return this.position === other.position &&
+            this.numberingFormat === other.numberingFormat &&
+            this.numberingRestartType === other.numberingRestartType &&
+            this.startingNumber === other.startingNumber &&
+            this.columnCount === other.columnCount;
+    }
+}
+export class NoteSeparators {
+    constructor(model) {
+        this.model = model;
+    }
+    get separator() {
+        return this.model.subDocuments[this.separatorId];
+    }
+    get continuationSeparator() {
+        return this.model.subDocuments[this.continuationSeparatorId];
+    }
+    get continuationNotice() {
+        return this.model.subDocuments[this.continuationNoticeId];
+    }
+    setSeparator(sudDocId, type) {
+        switch (type) {
+            case NoteType.Separator:
+                this.separatorId = sudDocId;
+                break;
+            case NoteType.ContinuationSeparator:
+                this.continuationSeparatorId = sudDocId;
+                break;
+            case NoteType.ContinuationNotice:
+                this.continuationNoticeId = sudDocId;
+                break;
+            default:
+                throw Error("Invalid separator type.");
+        }
+    }
+    getSeparator(type) {
+        switch (type) {
+            case NoteType.Separator:
+                return this.separator;
+            case NoteType.ContinuationSeparator:
+                return this.continuationSeparator;
+            case NoteType.ContinuationNotice:
+                return this.continuationNotice;
+            default:
+                throw Error("Invalid separator type.");
+        }
+    }
+    *getSeparatos() {
+        if (this.separator)
+            yield this.separator;
+        if (this.continuationSeparator)
+            yield this.continuationSeparator;
+        if (this.continuationNotice)
+            yield this.continuationNotice;
+    }
+}

package/lib/common/model/json/importers/sub-document/json-sub-document-importer.js

@@ -15,7 +15,7 @@ import { JSONRunBaseProperty } from '../../enums/json-run-enums';
 import { JSONBookmarkProperty, JSONChunkProperty, JSONEnumLoadPieceTable, JSONRangePermissionProperty } from '../../enums/json-sub-document-enums';
 import { JSONTabConverter } from '../json-tab-converter';
 import { JSONTableImporter } from '../table/json-table-importer';
-import { AnchoredPictureRunImporter, AnchoredTextBoxRunImporter, InlinePictureRunImporter, InlineTextBoxRunImporter, SimpleRunImporter, TextRunImporter } from './run-importers';
+import { AnchoredPictureRunImporter, AnchoredTextBoxRunImporter, InlinePictureRunImporter, InlineTextBoxRunImporter, NoteRunImporter, SimpleRunImporter, TextRunImporter } from './run-importers';
 export class JSONSubDocumentImporter {
     static importSubDocument(subDocument, documentProtectionSettings, content, imageCorrespondence) {
         JSONTableImporter.importTables(subDocument, content[JSONEnumLoadPieceTable.Tables]);
@@ -119,8 +119,8 @@ JSONSubDocumentImporter.runTypeToRunImporter = {
     [RunType.InlinePictureRun]: new InlinePictureRunImporter(),
     [RunType.InlineTextBoxRun]: new InlineTextBoxRunImporter(),
     [RunType.LayoutDependentRun]: new SimpleRunImporter(LayoutDependentRun),
-    [RunType.FootNoteRun]: new SimpleRunImporter(FootNoteRun),
-    [RunType.EndNoteRun]: new SimpleRunImporter(EndNoteRun),
+    [RunType.FootNoteRun]: new NoteRunImporter(FootNoteRun),
+    [RunType.EndNoteRun]: new NoteRunImporter(EndNoteRun),
     [RunType.NoteSeparatorRun]: new SimpleRunImporter(NoteSeparatorRun),
     [RunType.NoteContinuationSeparatorRun]: new SimpleRunImporter(NoteContinuationSeparatorRun),
 };

package/lib/common/model/json/importers/sub-document/run-importers.d.ts

@@ -5,6 +5,7 @@ import { CharacterStyle } from '../../../character/character-style';
 import { Paragraph } from '../../../paragraph/paragraph';
 import { RunBase } from '../../../runs/run-base';
 export declare type SimpleRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle) => RunBase;
+export declare type NoteRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle, noteDocumentId: number) => RunBase;
 export declare abstract class BaseRunImporter {
     private maskedCharacterPropertiesCache;
     private charStyles;
@@ -19,6 +20,11 @@ export declare class SimpleRunImporter extends BaseRunImporter {
     constructor(runConstructor: SimpleRunConstructor);
     protected makeRun(_jsonRun: any, startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle): RunBase;
 }
+export declare class NoteRunImporter extends BaseRunImporter {
+    runConstructor: NoteRunConstructor;
+    constructor(runConstructor: NoteRunConstructor);
+    protected makeRun(_jsonRun: any, startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle): RunBase;
+}
 export declare class TextRunImporter extends BaseRunImporter {
     protected makeRun(jsonRun: any, startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle): RunBase;
 }

package/lib/common/model/json/importers/sub-document/run-importers.js

@@ -34,6 +34,15 @@ export class SimpleRunImporter extends BaseRunImporter {
         return new this.runConstructor(startOffset, paragraph, charPropsBundle);
     }
 }
+export class NoteRunImporter extends BaseRunImporter {
+    constructor(runConstructor) {
+        super();
+        this.runConstructor = runConstructor;
+    }
+    makeRun(_jsonRun, startOffset, paragraph, charPropsBundle) {
+        return new this.runConstructor(startOffset, paragraph, charPropsBundle, -1);
+    }
+}
 export class TextRunImporter extends BaseRunImporter {
     makeRun(jsonRun, startOffset, paragraph, charPropsBundle) {
         return new TextRun(startOffset, jsonRun[JSONRunBaseProperty.Length], paragraph, charPropsBundle);

package/lib/common/model/model-checks/position.d.ts

@@ -7,7 +7,8 @@ export declare class PositionChecker {
     check(): boolean;
     compare(poss: Position[], registered: Position[]): boolean;
     private getNewRegInterval;
-    private checkValue;
+    private isGreater;
+    private isEqual;
     private sort;
     private addSections;
     private addParagraphs;

package/lib/common/model/model-checks/position.js

@@ -27,7 +27,9 @@ export class PositionChecker {
         for (let currPos of poss) {
             if (prevPos.value != currPos.value)
                 regInterval = this.getNewRegInterval(registered, regInterval);
-            if (!this.checkValue(currPos, registered, regInterval))
+            while (this.isGreater(currPos, registered, regInterval))
+                regInterval = this.getNewRegInterval(registered, regInterval);
+            if (!this.isEqual(currPos, registered, regInterval))
                 return false;
             prevPos = currPos;
         }
@@ -43,7 +45,14 @@ export class PositionChecker {
         }
         return regInterval;
     }
-    checkValue(currPos, registered, regInterval) {
+    isGreater(currPos, registered, regInterval) {
+        for (let i = regInterval.start; i < regInterval.end; i++) {
+            if (registered[i] && currPos.value > registered[i].value)
+                return true;
+        }
+        return false;
+    }
+    isEqual(currPos, registered, regInterval) {
         for (let i = regInterval.start; i < regInterval.end; i++) {
             if (currPos === registered[i])
                 return true;

package/lib/common/model/numbering-lists/numbering-helper.d.ts

@@ -1,13 +1,14 @@
 import { IModelManager } from '../../model-manager';
 import { DocumentModel } from '../document-model';
 import { SubDocument } from '../sub-document';
-import { NumberingType } from './numbering-list';
+import { AbstractNumberingList, NumberingType } from './numbering-list';
 export declare class NumberingHelper {
     static templateCodeStart: number;
     static templateCodeEnd: number;
     static generateNewTemplateCode(documentModel: DocumentModel): number;
     static isNewTemplateCode(documentModel: DocumentModel, templateCode: number): boolean;
     static getNumberingListTemplateIndex(documentModel: DocumentModel, type: NumberingType): number;
+    static getNumberingListTemplate(documentModel: DocumentModel, type: NumberingType): AbstractNumberingList;
     static deleteNumberingList(modelManager: IModelManager, subDocument: SubDocument, paragraphIndices: number[]): void;
     private static resetParagraphLeftIndent;
     private static deleteNumberingListCore;

package/lib/common/model/numbering-lists/numbering-helper.js

@@ -26,6 +26,9 @@ export class NumberingHelper {
         }
         return -1;
     }
+    static getNumberingListTemplate(documentModel, type) {
+        return documentModel.abstractNumberingListTemplates.find(list => list.getListType() === type);
+    }
     static deleteNumberingList(modelManager, subDocument, paragraphIndices) {
         for (let i = paragraphIndices.length - 1; i >= 0; i--) {
             let paragraphIndex = paragraphIndices[i];

package/lib/common/model/paragraph/paragraph-style.d.ts

@@ -24,6 +24,7 @@ export declare class ParagraphStyle extends StyleBase<ParagraphStyle> implements
     getResultTabs(): TabProperties;
     getMergedParagraphProperties(): ParagraphProperties;
     isInOwnList(): boolean;
+    isInList(): boolean;
     getListLevel(model: DocumentModel): IOverrideListLevel;
     getNumberingList(model: DocumentModel): NumberingList;
     getNumberingListIndex(): number;

package/lib/common/model/paragraph/paragraph-style.js

@@ -29,6 +29,9 @@ export class ParagraphStyle extends StyleBase {
     isInOwnList() {
         return this.numberingListIndex >= 0;
     }
+    isInList() {
+        return this.getNumberingListIndex() >= 0;
+    }
     getListLevel(model) {
         return this.getNumberingList(model).levels[this.getListLevelIndex()];
     }
@@ -42,10 +45,11 @@ export class ParagraphStyle extends StyleBase {
             return this.parent.getNumberingListIndex();
     }
     getListLevelIndex() {
-        if (this.listLevelIndex >= 0 || this.listLevelIndex === NumberingList.NoNumberingListIndex || !this.parent)
+        var _a, _b;
+        if (this.listLevelIndex >= 0)
             return this.listLevelIndex;
         else
-            return this.parent.getListLevelIndex();
+            return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getListLevelIndex()) !== null && _b !== void 0 ? _b : 0;
     }
     clone() {
         const style = new ParagraphStyle(this.styleName, this.localizedName, this.deleted, this.hidden, this.semihidden, this.isDefault, this.maskedCharacterProperties, this.maskedParagraphProperties, this.tabs.clone(), this.autoUpdate, this.numberingListIndex, this.listLevelIndex, this.base64EncodedImage, this.id);

package/lib/common/model/properties-merger/paragraph-properties-merger.js

@@ -38,7 +38,7 @@ export class ParagraphPropertiesMerger extends PropertiesMergerBase {
         let currentParagraphStyle = paragraphStyle;
         while (currentParagraphStyle) {
             this.merge(currentParagraphStyle.maskedParagraphProperties);
-            if (currentParagraphStyle.isInOwnList())
+            if (currentParagraphStyle.isInList())
                 this.merge(currentParagraphStyle.getListLevel(model).getParagraphProperties());
             currentParagraphStyle = currentParagraphStyle.parent;
         }

package/lib/common/model/runs/run-base.d.ts

@@ -23,6 +23,7 @@ export declare abstract class RunBase implements ICharacterPropertiesContainer,
     paragraph: Paragraph;
     characterStyle: CharacterStyle;
     maskedCharacterProperties: MaskedCharacterProperties;
+    noteDocumentId: number;
     private mergedCharacterProperties;
     constructor(startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle);
     abstract getLength(): number;

package/lib/common/model/runs/simple-runs.d.ts

@@ -1,7 +1,9 @@
 import { ICloneable } from '@devexpress/utils/lib/types';
+import { MaskedCharacterPropertiesBundle } from '../../rich-utils/properties-bundle';
 import { SubDocument } from '../sub-document';
 import { OneCharRun } from './run-base';
 import { RunType } from './run-type';
+import { Paragraph } from '../paragraph/paragraph';
 export declare class SectionRun extends OneCharRun implements ICloneable<SectionRun> {
     getType(): RunType;
     isParagraphOrSectionRun(): boolean;
@@ -34,12 +36,15 @@ export declare class LayoutDependentRun extends OneCharRun implements ICloneable
     clone(): LayoutDependentRun;
     cloneToNewSubDocument(subDocument: SubDocument): LayoutDependentRun;
 }
-export declare class FootNoteRun extends OneCharRun implements ICloneable<FootNoteRun> {
+declare abstract class NoteRun extends OneCharRun {
+    constructor(startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle, noteDocumentId?: number);
+}
+export declare class FootNoteRun extends NoteRun implements ICloneable<FootNoteRun> {
     getType(): RunType;
     clone(): FootNoteRun;
     cloneToNewSubDocument(subDocument: SubDocument): FootNoteRun;
 }
-export declare class EndNoteRun extends OneCharRun implements ICloneable<EndNoteRun> {
+export declare class EndNoteRun extends NoteRun implements ICloneable<EndNoteRun> {
     getType(): RunType;
     clone(): EndNoteRun;
     cloneToNewSubDocument(subDocument: SubDocument): EndNoteRun;
@@ -54,3 +59,4 @@ export declare class NoteContinuationSeparatorRun extends OneCharRun implements
     clone(): NoteContinuationSeparatorRun;
     cloneToNewSubDocument(subDocument: SubDocument): NoteContinuationSeparatorRun;
 }
+export {};