@univerjs/docs 1.0.0-alpha.1 → 1.0.0-alpha.3

package/lib/es/facade.js

@@ -1,240 +1,278 @@
-import { DocumentBlockType, ICommandService, IResourceLoaderService, IUniverInstanceService, Inject, Injector, JSONX, PresetListType, RESTORE_INSERTED_PARAGRAPH_IDS, RedoCommand, TextX, TextXActionType, UndoCommand, UniverInstanceType, UpdateDocsAttributeType, createParagraphId, getRichTextEditPath } from "@univerjs/core";
-import { FBase, FBaseInitialable, FUniver } from "@univerjs/core/facade";
-import { RichTextEditingMutation } from "@univerjs/docs";
+import { BooleanNumber, ColumnSeparatorType, DashStyleType, DataStreamTreeTokenType, DocumentFlavor, ICommandService, IResourceLoaderService, IUniverInstanceService, Inject, Injector, JSONX, PresetListType, RESTORE_INSERTED_PARAGRAPH_IDS, RedoCommand, SectionType, TextX, TextXActionType, Tools, UndoCommand, UniverInstanceType, UpdateDocsAttributeType, createParagraphId, createSectionId, generateRandomId, getParagraphContentStartOffset, getRichTextEditPath, getSectionHeaderFooterReferenceKey, resolveSectionHeaderFooterReference } from "@univerjs/core";
+import { FBaseInitialable, FEnum, FUniver } from "@univerjs/core/facade";
+import { CreateHeaderFooterCommand, DeleteDocumentSectionBreakCommand, HeaderFooterType, InsertDocumentSectionBreakCommand, RichTextEditingMutation, SetSectionHeaderFooterLinkCommand, UpdateDocumentSectionCommand, createSectionColumnProperties, generateParagraphs, getTopLevelSectionBreaks } from "@univerjs/docs";
 
-//#region src/facade/f-document-element.ts
+//#region src/facade/utils.ts
+function cloneParagraphStyle(paragraphStyle) {
+	return paragraphStyle == null ? paragraphStyle : JSON.parse(JSON.stringify(paragraphStyle));
+}
+function normalizePlainTextDataStream(dataStream) {
+	return dataStream.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
+}
+function getRemovedLeadingParagraphBreakLength(dataStream, removeLeadingParagraphBreak) {
+	const normalized = normalizePlainTextDataStream(dataStream);
+	if (removeLeadingParagraphBreak && normalized.length > 1 && normalized.startsWith("\r")) return 1;
+	return 0;
+}
+function buildPlainTextInsertBody(dataStream, options = {}) {
+	const normalizedDataStream = normalizePlainTextDataStream(dataStream).slice(getRemovedLeadingParagraphBreakLength(dataStream, options.removeLeadingParagraphBreak));
+	const body = {
+		dataStream: normalizedDataStream,
+		customDecorations: [],
+		customRanges: [],
+		textRuns: []
+	};
+	const paragraphs = [];
+	const existingParagraphIds = /* @__PURE__ */ new Set();
+	for (let index = 0; index < normalizedDataStream.length; index++) if (normalizedDataStream[index] === "\r") paragraphs.push({
+		startIndex: index,
+		paragraphId: createParagraphId(existingParagraphIds),
+		...options.paragraphStyle == null ? {} : { paragraphStyle: cloneParagraphStyle(options.paragraphStyle) }
+	});
+	if (paragraphs.length > 0) body.paragraphs = paragraphs;
+	return body;
+}
+function replaceBodyRange(range, insertBody, docDataModel, injector) {
+	const { startOffset, endOffset, segmentId } = range;
+	const textX = new TextX();
+	if (startOffset > 0) textX.push({
+		t: TextXActionType.RETAIN,
+		len: startOffset
+	});
+	if (endOffset > startOffset) textX.push({
+		t: TextXActionType.DELETE,
+		len: endOffset - startOffset
+	});
+	if (insertBody.dataStream.length > 0) textX.push({
+		t: TextXActionType.INSERT,
+		body: insertBody,
+		len: insertBody.dataStream.length
+	});
+	const actions = JSONX.getInstance().editOp(textX.serialize(), getRichTextEditPath(docDataModel, segmentId));
+	const result = injector.get(ICommandService).syncExecuteCommand(RichTextEditingMutation.id, {
+		unitId: docDataModel.getUnitId(),
+		segmentId,
+		actions,
+		textRanges: [],
+		isEditing: false
+	});
+	return Boolean((result === null || result === void 0 ? void 0 : result.actions) && result.actions.length > 0);
+}
+function retainBodyRange(range, updateBody, coverType, docDataModel, injector) {
+	var _updateBody$textRuns, _docDataModel$getSelf;
+	const { startOffset, endOffset, segmentId } = range;
+	const commandService = injector.get(ICommandService);
+	if (((_updateBody$textRuns = updateBody.textRuns) === null || _updateBody$textRuns === void 0 ? void 0 : _updateBody$textRuns.length) && ((_docDataModel$getSelf = docDataModel.getSelfOrHeaderFooterModel(segmentId)) === null || _docDataModel$getSelf === void 0 || (_docDataModel$getSelf = _docDataModel$getSelf.getBody()) === null || _docDataModel$getSelf === void 0 ? void 0 : _docDataModel$getSelf.textRuns) == null) {
+		const actions = JSONX.getInstance().replaceOp([...getRichTextEditPath(docDataModel, segmentId), "textRuns"], void 0, []);
+		commandService.syncExecuteCommand(RichTextEditingMutation.id, {
+			unitId: docDataModel.getUnitId(),
+			segmentId,
+			actions,
+			textRanges: [],
+			isEditing: false
+		});
+	}
+	const textX = new TextX();
+	if (startOffset > 0) textX.push({
+		t: TextXActionType.RETAIN,
+		len: startOffset
+	});
+	textX.push({
+		t: TextXActionType.RETAIN,
+		body: updateBody,
+		coverType,
+		len: endOffset - startOffset
+	});
+	const actions = JSONX.getInstance().editOp(textX.serialize(), getRichTextEditPath(docDataModel, segmentId));
+	const result = commandService.syncExecuteCommand(RichTextEditingMutation.id, {
+		unitId: docDataModel.getUnitId(),
+		segmentId,
+		actions,
+		textRanges: [],
+		isEditing: false
+	});
+	return Boolean((result === null || result === void 0 ? void 0 : result.actions) && result.actions.length > 0);
+}
+function stripBlockTokens(text) {
+	return Array.from(text).map((char) => char === DataStreamTreeTokenType.PARAGRAPH ? "\n" : char).filter((char) => char !== DataStreamTreeTokenType.BLOCK_START && char !== DataStreamTreeTokenType.BLOCK_END && char !== DataStreamTreeTokenType.SECTION_BREAK).join("").replace(/\n$/, "");
+}
+
+//#endregion
+//#region src/facade/f-document-text-range.ts
 /**
-* A generic top-level document body element.
-*
-* Use this wrapper when you need to inspect an element type first, navigate to
-* neighboring elements, or cast the element to a more specific facade wrapper.
-*
-* Paragraph keys are persisted `paragraphId` values. Tables, block ranges, and
-* custom blocks use their persisted ids.
+* Facade wrapper for reading and styling a fixed document text range.
 *
+* Offsets are fixed when the wrapper is created. Create a new range after edits
+* that insert or remove content before it.
 * @hideconstructor
 */
-var FDocumentElement = class extends FBase {
-	constructor(_body, _bodyEdit, _info, _injector) {
-		super();
-		this._body = _body;
-		this._bodyEdit = _bodyEdit;
-		this._info = _info;
+var FDocumentTextRange = class {
+	constructor(_document, _startOffset, _endOffset, _segmentId, _injector) {
+		this._document = _document;
+		this._startOffset = _startOffset;
+		this._endOffset = _endOffset;
+		this._segmentId = _segmentId;
 		this._injector = _injector;
+		this._validateRange();
 	}
 	/**
-	* Get the document element type.
-	* @returns {DocumentBlockType} The element type, such as `paragraph`, `table`, `blockRange`, or `customBlock`.
-	* @example
-	* ```ts
-	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.getType());
-	* ```
-	*/
-	getType() {
-		return this._info.type;
-	}
-	/**
-	* Whether this element is a paragraph.
-	* @returns {boolean} `true` if this element is a paragraph.
-	* @example
-	* ```ts
-	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.isParagraph());
-	* ```
-	*/
-	isParagraph() {
-		return this._info.type === DocumentBlockType.PARAGRAPH;
-	}
-	/**
-	* Whether this element is a table.
-	* @returns {boolean} `true` if this element is a table.
+	* Returns the serializable document range.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.isTable());
+	* const range = fDocument?.findParagraphByText('Launch')?.getTextRange();
+	* console.log(range?.getRange());
 	* ```
 	*/
-	isTable() {
-		return this._info.type === DocumentBlockType.TABLE;
-	}
-	/**
-	* Whether this element is a block range, such as a callout, quote, or code block.
-	* @returns {boolean} `true` if this element is a block range.
-	* @example
-	* ```ts
-	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.isBlockRange());
-	* ```
-	*/
-	isBlockRange() {
-		return this._info.type === DocumentBlockType.BLOCK_RANGE;
+	getRange() {
+		return {
+			startOffset: this._startOffset,
+			endOffset: this._endOffset,
+			segmentId: this._segmentId
+		};
 	}
 	/**
-	* Whether this element is a custom block.
-	* @returns {boolean} `true` if this element is a custom block.
+	* Returns the plain data-stream text in this range.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.isCustomBlock());
+	* const range = fDocument?.findParagraphByText('Launch')?.getTextRange();
+	* console.log(range?.getText());
 	* ```
 	*/
-	isCustomBlock() {
-		return this._info.type === DocumentBlockType.CUSTOM_BLOCK;
+	getText() {
+		return this._document.getBody(this._segmentId).dataStream.slice(this._startOffset, this._endOffset);
 	}
 	/**
-	* Get the facade key used to resolve this element.
-	* @returns {string} The paragraph `paragraphId` or persisted table/block/custom block id.
+	* Returns explicit text-style runs intersecting this range.
+	* Returned offsets are clipped to the range and remain document-relative.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.getKey());
+	* const range = fDocument?.findParagraphByText('Launch')?.getTextRange();
+	* console.log(range?.getExplicitTextStyleRuns());
 	* ```
 	*/
-	getKey() {
-		return this._info.key;
+	getExplicitTextStyleRuns() {
+		const { textRuns = [] } = this._document.getBody(this._segmentId);
+		return textRuns.filter((run) => run.st < this._endOffset && run.ed > this._startOffset).map((run) => {
+			var _run$ts;
+			return {
+				startOffset: Math.max(run.st, this._startOffset),
+				endOffset: Math.min(run.ed, this._endOffset),
+				textStyle: Tools.deepClone((_run$ts = run.ts) !== null && _run$ts !== void 0 ? _run$ts : {})
+			};
+		});
 	}
-	/**
-	* Get the parent body facade that owns this element.
-	* @returns {FDocumentBody} The document body facade.
-	* @example
-	* ```ts
-	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.getParent());
-	* ```
-	*/
-	getParent() {
-		return this._body;
+	/** @deprecated Use `getExplicitTextStyleRuns()` to distinguish stored styles from effective styles. */
+	getTextStyleRuns() {
+		return this.getExplicitTextStyleRuns();
 	}
 	/**
-	* Get the resolved element info for this wrapper.
-	* @returns {IFDocumentElementInfo} The resolved element info, including type, key, position, and priority.
+	* Returns top-level style properties that have the same explicit value
+	* across the complete range. Unstyled gaps make a property non-common.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.getResolvedInfo());
+	* const range = fDocument?.findParagraphByText('Launch')?.getTextRange();
+	* console.log(range?.getCommonExplicitTextStyle());
 	* ```
 	*/
-	getResolvedInfo() {
-		return this._info;
+	getCommonExplicitTextStyle() {
+		if (this._startOffset === this._endOffset) return {};
+		const [first, ...rest] = this._getStyleSegments();
+		const common = Tools.deepClone(first.textStyle);
+		for (const key of Object.keys(common)) if (rest.some((run) => !isDeepEqual(run.textStyle[key], common[key]))) delete common[key];
+		return common;
 	}
-	/**
-	* Get the next sibling element in the current body order.
-	* @returns {FDocumentElement | null} The next sibling wrapper, or `null` when this is the last child.
-	* @example
-	* ```ts
-	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element?.getNextSibling());
-	* ```
-	*/
-	getNextSibling() {
-		return this._createSibling(1);
+	/** @deprecated Use `getCommonExplicitTextStyle()` to distinguish stored styles from effective styles. */
+	getCommonTextStyle() {
+		return this.getCommonExplicitTextStyle();
 	}
 	/**
-	* Get the previous sibling element in the current body order.
-	* @returns {FDocumentElement | null} The previous sibling wrapper, or `null` when this is the first child.
+	* Returns a serializable summary suitable for an agent/tool response.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(1);
-	* console.log(element?.getPreviousSibling());
+	* const range = fDocument?.findParagraphByText('Launch')?.getTextRange();
+	* console.log(range?.describe());
 	* ```
 	*/
-	getPreviousSibling() {
-		return this._createSibling(-1);
+	describe() {
+		const explicitTextStyleRuns = this.getExplicitTextStyleRuns();
+		const commonExplicitTextStyle = this.getCommonExplicitTextStyle();
+		return {
+			...this.getRange(),
+			text: this.getText(),
+			length: this._endOffset - this._startOffset,
+			explicitTextStyleRuns,
+			commonExplicitTextStyle,
+			textStyleRuns: explicitTextStyleRuns,
+			commonTextStyle: commonExplicitTextStyle
+		};
 	}
 	/**
-	* Get the sibling element at a relative offset from this element.
-	* @param {number} offset The relative offset from this element. Use `1` for the next sibling, `-1` for the previous sibling, and so on.
-	* @returns {FDocumentElement | null} The sibling wrapper at the specified offset, or `null` when the offset is out of range.
+	* Merges a text-style patch into every character in the range.
+	* Existing text-run splitting, merging, and normalization are handled by
+	* the document mutation pipeline.
+	* `style.fs` is a font size in points (pt), not CSS pixels.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* // Get the third sibling after this element
-	* const nextThirdSibling = element?.getSibling(3);
-	* console.log(nextThirdSibling?.getType());
+	* const range = fDocument?.findParagraphByText('Launch')?.getTextRange();
+	* range?.setTextStyle({ fs: 10.5, bl: univerAPI.Enum.BooleanNumber.TRUE });
 	* ```
 	*/
-	getSibling(offset) {
-		return this._createSibling(offset);
+	setTextStyle(style) {
+		if (this._startOffset === this._endOffset) return false;
+		return retainBodyRange(this.getRange(), {
+			dataStream: "",
+			textRuns: [{
+				st: 0,
+				ed: this._endOffset - this._startOffset,
+				ts: Tools.deepClone(style)
+			}]
+		}, UpdateDocsAttributeType.COVER, this._document.getDocumentDataModel(), this._injector);
 	}
 	/**
-	* Remove this element from its parent body.
-	* @returns {boolean} `true` if the element content was removed.
+	* Replaces the range with plain text while preserving document mutation semantics.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* const removed = element?.remove();
-	* console.log(removed);
+	* const range = fDocument?.findParagraphByText('Draft')?.getTextRange();
+	* range?.setText('Final');
 	* ```
 	*/
-	remove() {
-		if (this.isParagraph()) return this._body.removeParagraph(this.asParagraph());
-		if (this.isBlockRange()) return this._body.removeBlockRange(this.asBlockRange());
-		if (this.isTable()) return this._body.removeTable(this.asTable());
-		return this._body.removeCustomBlock(this.asCustomBlock());
-	}
-	_createSibling(offset) {
-		if (offset === 0) throw new Error("Offset cannot be zero.");
-		const index = this._body.getElementIndex(this);
-		return this._body.getElement(index + offset);
+	setText(text) {
+		return replaceBodyRange(this.getRange(), buildPlainTextInsertBody(text), this._document.getDocumentDataModel(), this._injector);
+	}
+	_validateRange() {
+		const bodyLength = this._document.getBody(this._segmentId).dataStream.length;
+		if (!Number.isInteger(this._startOffset) || !Number.isInteger(this._endOffset) || this._startOffset < 0 || this._endOffset < this._startOffset || this._endOffset > bodyLength) throw new RangeError(`Invalid document text range [${this._startOffset}, ${this._endOffset}) for body length ${bodyLength}.`);
+	}
+	_getStyleSegments() {
+		const explicitRuns = this.getExplicitTextStyleRuns();
+		const segments = [];
+		let offset = this._startOffset;
+		for (const run of explicitRuns) {
+			if (offset < run.startOffset) segments.push({
+				startOffset: offset,
+				endOffset: run.startOffset,
+				textStyle: {}
+			});
+			segments.push(run);
+			offset = run.endOffset;
+		}
+		if (offset < this._endOffset) segments.push({
+			startOffset: offset,
+			endOffset: this._endOffset,
+			textStyle: {}
+		});
+		return segments;
 	}
 };
-
-//#endregion
-//#region src/facade/utils.ts
-function cloneParagraphStyle(paragraphStyle) {
-	return paragraphStyle == null ? paragraphStyle : JSON.parse(JSON.stringify(paragraphStyle));
-}
-function normalizePlainTextDataStream(dataStream) {
-	return dataStream.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
-}
-function getRemovedLeadingParagraphBreakLength(dataStream, removeLeadingParagraphBreak) {
-	const normalized = normalizePlainTextDataStream(dataStream);
-	if (removeLeadingParagraphBreak && normalized.length > 1 && normalized.startsWith("\r")) return 1;
-	return 0;
-}
-function buildPlainTextInsertBody(dataStream, options = {}) {
-	const normalizedDataStream = normalizePlainTextDataStream(dataStream).slice(getRemovedLeadingParagraphBreakLength(dataStream, options.removeLeadingParagraphBreak));
-	const body = {
-		dataStream: normalizedDataStream,
-		customDecorations: [],
-		customRanges: [],
-		textRuns: []
-	};
-	const paragraphs = [];
-	const existingParagraphIds = /* @__PURE__ */ new Set();
-	for (let index = 0; index < normalizedDataStream.length; index++) if (normalizedDataStream[index] === "\r") paragraphs.push({
-		startIndex: index,
-		paragraphId: createParagraphId(existingParagraphIds),
-		...options.paragraphStyle == null ? {} : { paragraphStyle: cloneParagraphStyle(options.paragraphStyle) }
-	});
-	if (paragraphs.length > 0) body.paragraphs = paragraphs;
-	return body;
+function isDeepEqual(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
 }
 
 //#endregion
@@ -248,14 +286,12 @@ function buildPlainTextInsertBody(dataStream, options = {}) {
 *
 * @hideconstructor
 */
-var FDocumentParagraph = class extends FDocumentElement {
-	constructor(body, bodyEdit, info, injector) {
-		super(body, bodyEdit, info, injector);
-		this.body = body;
-		this.bodyEdit = bodyEdit;
-		this.info = info;
-		this.injector = injector;
-		if (this.getType() !== DocumentBlockType.PARAGRAPH) throw new Error(`Element type is not a paragraph: ${this.getType()}`);
+var FDocumentParagraph = class {
+	constructor(_document, _paragraphId, _segmentId = "", _injector) {
+		this._document = _document;
+		this._paragraphId = _paragraphId;
+		this._segmentId = _segmentId;
+		this._injector = _injector;
 	}
 	/**
 	* Get the persisted paragraph id.
@@ -263,46 +299,52 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   console.log(paragraph.getParagraphId());
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.getId());
 	* ```
 	*/
-	getParagraphId() {
-		return this.getKey();
+	getId() {
+		return this._paragraphId;
 	}
 	/**
-	* Get the resolved paragraph info for this wrapper.
-	* @returns {IFDocumentResolvedParagraph} The resolved paragraph info, including the paragraph object, its index, and its text range.
+	* Get the segment id of this paragraph.
+	* The main body paragraphs have an empty string segment id.
+	* The header and footer paragraphs have a non-empty string segment id.
+	* @returns {string} The segment id.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   console.log(paragraph.getResolvedParagraphInfo());
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.getSegmentId());
+	* ```
+	*/
+	getSegmentId() {
+		return this._segmentId;
+	}
+	/**
+	* Get this paragraph's metadata.
+	* @returns {IFDocumentParagraphInfo} The paragraph info.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.getInfo());
 	* ```
 	*/
-	getResolvedParagraphInfo() {
-		const { paragraphs = [] } = this._body.getBody();
+	getInfo() {
+		const body = this._document.getBody(this._segmentId);
+		const { paragraphs = [] } = body;
 		const matches = paragraphs.map((paragraph, paragraphIndex) => ({
 			paragraph,
 			paragraphIndex
-		})).filter(({ paragraph }) => paragraph.paragraphId === this.getKey());
-		if (matches.length === 0) throw new Error(`Document paragraph with id ${this.getKey()} not found`);
-		if (matches.length > 1) throw new Error(`Multiple document paragraphs with id ${this.getKey()} found`);
+		})).filter(({ paragraph }) => paragraph.paragraphId === this._paragraphId);
+		if (matches.length === 0) throw new Error(`Document paragraph with id ${this._paragraphId} not found`);
+		if (matches.length > 1) throw new Error(`Multiple document paragraphs with id ${this._paragraphId} found`);
 		const { paragraph, paragraphIndex } = matches[0];
 		return {
 			paragraph,
 			paragraphIndex,
-			startOffset: paragraphIndex > 0 ? paragraphs[paragraphIndex - 1].startIndex + 1 : 0,
+			startOffset: getParagraphContentStartOffset(body, paragraph),
 			endOffset: paragraph.startIndex
 		};
 	}
@@ -312,42 +354,46 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   const range = paragraph.getRange();
-	*   fDocumentBody.setTextStyle(range, { bl: 1 });
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.getRange());
 	* ```
 	*/
 	getRange() {
-		const { startOffset, endOffset } = this.getResolvedParagraphInfo();
+		const { startOffset, endOffset } = this.getInfo();
 		return {
 			startOffset,
 			endOffset,
-			segmentId: this._body.getSegmentId()
+			segmentId: this._segmentId
 		};
 	}
 	/**
+	* Returns an agent-friendly facade for reading and styling this paragraph's text.
+	* @returns {FDocumentTextRange} The paragraph text range, excluding the trailing paragraph break.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument?.findParagraphByText('Launch');
+	* const range = paragraph?.getTextRange();
+	* console.log(range?.describe());
+	* ```
+	*/
+	getTextRange() {
+		const { startOffset, endOffset } = this.getInfo();
+		return this._injector.createInstance(FDocumentTextRange, this._document, startOffset, endOffset, this._segmentId, this._injector);
+	}
+	/**
 	* Get this paragraph's plain text.
 	* @returns {string} The paragraph text without the trailing paragraph break.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   console.log(paragraph.getText());
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.getText());
 	* ```
 	*/
 	getText() {
-		const { dataStream } = this._body.getBody();
-		const { startOffset, endOffset } = this.getResolvedParagraphInfo();
+		const { dataStream } = this._document.getBody(this._segmentId);
+		const { startOffset, endOffset } = this.getInfo();
 		return dataStream.slice(startOffset, endOffset);
 	}
 	/**
@@ -357,22 +403,18 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   const success = paragraph.setText('Updated title');
-	*   console.log(success ? 'Text updated' : 'Failed to update text');
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* paragraph?.setText('New text');
+	* console.log(paragraph?.getText());
 	* ```
 	*/
 	setText(text) {
-		const { startOffset, endOffset } = this.getResolvedParagraphInfo();
-		return this._bodyEdit.replaceRange({
+		const { startOffset, endOffset } = this.getInfo();
+		return replaceBodyRange({
 			startOffset,
-			endOffset
-		}, buildPlainTextInsertBody(text));
+			endOffset,
+			segmentId: this._segmentId
+		}, buildPlainTextInsertBody(text), this._document.getDocumentDataModel(), this._injector);
 	}
 	/**
 	* Append plain text before this paragraph's trailing paragraph break.
@@ -381,38 +423,52 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   const success = paragraph.appendText(' Appended text');
-	*   console.log(success ? 'Text appended' : 'Failed to append text');
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* paragraph?.appendText(' Appended text');
+	* console.log(paragraph?.getText());
 	* ```
 	*/
 	appendText(text) {
-		const { endOffset } = this.getResolvedParagraphInfo();
-		return this._body.insertText(endOffset, text);
+		const { endOffset } = this.getInfo();
+		return this._document.insertText(endOffset, text, this._segmentId);
 	}
 	/**
 	* Apply paragraph style to a paragraph handle or text range.
+	* `style.textStyle.fs` is a font size in points (pt), not CSS pixels.
 	* @param {IParagraphStyle} style The Univer paragraph style patch.
 	* @returns {boolean} `true` if the style was applied.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   paragraph.setStyle({ horizontalAlign: 2 });
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* paragraph?.setText('Styled text');
+	* paragraph?.setStyle({
+	*   textStyle: {
+	*     cl: {
+	*       rgb: '#FF0000',
+	*     },
+	*     fs: 14,
+	*   },
+	*   horizontalAlign: 2,
+	* });
+	* console.log(paragraph?.getInfo().paragraph.paragraphStyle);
 	* ```
 	*/
 	setStyle(style) {
-		const { paragraph, endOffset } = this.getResolvedParagraphInfo();
+		const { paragraph, startOffset, endOffset } = this.getInfo();
+		let result = true;
+		if (style.textStyle && startOffset < endOffset) result = retainBodyRange({
+			startOffset,
+			endOffset,
+			segmentId: this._segmentId
+		}, {
+			dataStream: "",
+			textRuns: [{
+				st: 0,
+				ed: endOffset - startOffset,
+				ts: style.textStyle
+			}]
+		}, UpdateDocsAttributeType.COVER, this._document.getDocumentDataModel(), this._injector);
 		const updateBody = {
 			dataStream: "",
 			paragraphs: [{
@@ -425,10 +481,11 @@ var FDocumentParagraph = class extends FDocumentElement {
 			}]
 		};
 		this._preserveExplicitParagraphIds(updateBody);
-		return this._bodyEdit.retainRange({
+		return retainBodyRange({
 			startOffset: endOffset,
-			endOffset: endOffset + 1
-		}, updateBody, UpdateDocsAttributeType.REPLACE);
+			endOffset: endOffset + 1,
+			segmentId: this._segmentId
+		}, updateBody, UpdateDocsAttributeType.REPLACE, this._document.getDocumentDataModel(), this._injector) && result;
 	}
 	/**
 	* Check whether this paragraph is a bullet, ordered, or checklist item.
@@ -436,17 +493,12 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   console.log(paragraph.isListItem() ? 'This is a list item' : 'This is not a list item');
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.isListItem());
 	* ```
 	*/
 	isListItem() {
-		const { paragraph } = this.getResolvedParagraphInfo();
+		const { paragraph } = this.getInfo();
 		return Boolean(paragraph.bullet);
 	}
 	/**
@@ -455,18 +507,13 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   console.log(paragraph.isTask() ? 'This is a task item' : 'This is not a task item');
-	* }
+	* const paragraph = fDocument.getParagraphs()[0];
+	* console.log(paragraph?.isTask());
 	* ```
 	*/
 	isTask() {
 		var _paragraph$bullet;
-		const { paragraph } = this.getResolvedParagraphInfo();
+		const { paragraph } = this.getInfo();
 		const listType = (_paragraph$bullet = paragraph.bullet) === null || _paragraph$bullet === void 0 ? void 0 : _paragraph$bullet.listType;
 		return listType === PresetListType.CHECK_LIST || listType === PresetListType.CHECK_LIST_CHECKED;
 	}
@@ -477,22 +524,17 @@ var FDocumentParagraph = class extends FDocumentElement {
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
+	* const paragraph = fDocument.getParagraphs()[0];
 	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*
-	*   if (paragraph.isTask()) {
-	*     const success = paragraph.setTaskChecked(true);
-	*     console.log(success ? 'Task checked' : 'Failed to check task');
-	*   }
+	* if (paragraph.isTask()) {
+	*   const success = paragraph.setTaskChecked(true);
+	*   console.log(success ? 'Task checked' : 'Failed to check task');
 	* }
 	* ```
 	*/
 	setTaskChecked(checked) {
 		if (!this.isTask()) return false;
-		const { paragraph, endOffset } = this.getResolvedParagraphInfo();
+		const { paragraph, endOffset } = this.getInfo();
 		const bullet = paragraph.bullet;
 		const updateBody = {
 			dataStream: "",
@@ -506,494 +548,488 @@ var FDocumentParagraph = class extends FDocumentElement {
 			}]
 		};
 		this._preserveExplicitParagraphIds(updateBody);
-		return this._bodyEdit.retainRange({
+		return retainBodyRange({
 			startOffset: endOffset,
-			endOffset: endOffset + 1
-		}, updateBody, UpdateDocsAttributeType.REPLACE);
+			endOffset: endOffset + 1,
+			segmentId: this._segmentId
+		}, updateBody, UpdateDocsAttributeType.REPLACE, this._document.getDocumentDataModel(), this._injector);
+	}
+	/**
+	* Remove this paragraph.
+	* @returns {boolean} `true` if the paragraph was removed.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument.getParagraphs()[0];
+	* const success = paragraph?.remove();
+	* console.log(success ? 'Paragraph removed' : 'Failed to remove paragraph');
+	* ```
+	*/
+	remove() {
+		const { startOffset, endOffset } = this.getInfo();
+		return this._document.deleteRange({
+			startOffset,
+			endOffset: endOffset + 1,
+			segmentId: this._segmentId
+		});
 	}
 	_preserveExplicitParagraphIds(body) {
 		body[RESTORE_INSERTED_PARAGRAPH_IDS] = true;
 	}
 };
-var FDocumentParagraphMixin = class extends FDocumentElement {
-	asParagraph() {
-		if (this.getType() !== DocumentBlockType.PARAGRAPH) throw new Error(`Element type is not a paragraph: ${this.getType()}`);
-		return this._injector.createInstance(FDocumentParagraph, this._body, this._bodyEdit, this.getResolvedInfo(), this._injector);
-	}
-};
-FDocumentElement.extend(FDocumentParagraphMixin);
-
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/typeof.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-		return typeof o;
-	} : function(o) {
-		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-	}, _typeof(o);
+function isParagraphFacade(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof value.getId === "function" && typeof value.getSegmentId === "function" && typeof value.getInfo === "function" && typeof value.getRange === "function";
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPrimitive.js
-function toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) return t;
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) return i;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
+//#region src/facade/f-document-section.ts
+/** Error thrown when traditional section APIs are used to mutate a modern document. */
+var DocsSectionUnsupportedDocumentFlavorError = class extends Error {
+	constructor() {
+		super("Section column APIs are supported only in traditional documents. Use ColumnGroup APIs for modern documents.");
+		this.name = "DocsSectionUnsupportedDocumentFlavorError";
 	}
-	return ("string" === r ? String : Number)(t);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPropertyKey.js
-function toPropertyKey(t) {
-	var i = toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/defineProperty.js
-function _defineProperty(e, r, t) {
-	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-
-//#endregion
-//#region src/facade/f-document-body.ts
+};
 /**
-* A Facade API object bounded to a document body or header/footer segment.
-* It provides Google Docs-like element access and range editing methods.
-*
-* Paragraph elements use their persisted `paragraphId`. Tables, block ranges, and
-* custom blocks use their persisted ids.
-*
-* @hideconstructor
+* Facade wrapper for an OOXML-compatible traditional document section.
+* Modern documents use ColumnGroup APIs and cannot mutate this facade.
+* @example
+* ```ts
+* const fDocument = univerAPI.getActiveDocument();
+* if (fDocument && !fDocument.isModern()) {
+*   console.log(fDocument.getSection(0)?.describe());
+* }
+* ```
 */
-var FDocumentBody = class {
-	constructor(_documentDataModel, _injector, _segmentId = "") {
-		this._documentDataModel = _documentDataModel;
+var FDocumentSection = class {
+	constructor(_document, _sectionId, _injector) {
+		this._document = _document;
+		this._sectionId = _sectionId;
 		this._injector = _injector;
-		this._segmentId = _segmentId;
-		_defineProperty(this, "_bodyEdit", void 0);
-		this._bodyEdit = {
-			replaceRange: this._replaceBodyRange.bind(this),
-			retainRange: this._retainBodyRange.bind(this)
-		};
 	}
 	/**
-	* Get the segment id of this document body facade.
-	* The main body has an empty string segment id.
-	* The header and footer FDocumentBody instances have their respective segment ids.
-	* @returns {string} The segment id of this document body facade.
+	* Returns the persisted section id.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* console.log(fDocumentBody.getSegmentId());
+	* console.log(fDocument?.getSection(0)?.getId());
 	* ```
 	*/
-	getSegmentId() {
-		return this._segmentId;
+	getId() {
+		return this._sectionId;
 	}
 	/**
-	* Get the underlying document body snapshot.
-	* @returns {IDocumentBody} The document body snapshot.
+	* Returns the current zero-based section index.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* console.log(fDocumentBody.getBody());
+	* console.log(fDocument?.getSection(0)?.getIndex());
 	* ```
 	*/
-	getBody() {
-		const body = this._documentDataModel.getSelfOrHeaderFooterModel(this._segmentId).getBody();
-		if (!body) throw new Error("The document body is empty");
-		return body;
+	getIndex() {
+		return this._resolve().index;
 	}
 	/**
-	* Get a list of top-level child elements in the body.
-	* @returns {FDocumentElement[]} The list of top-level document elements.
+	* Returns the section break snapshot that terminates this section.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const elements = fDocumentBody.getElements();
-	* console.log(elements);
+	* console.log(fDocument?.getSection(0)?.getConfig());
 	* ```
 	*/
-	getElements() {
-		return this._getChildren().map((child) => {
-			return this._injector.createInstance(FDocumentElement, this, this._bodyEdit, child, this._injector);
-		});
+	getConfig() {
+		const { sectionBreak } = this._resolve();
+		return Tools.deepClone(sectionBreak);
 	}
 	/**
-	* Get a top-level child element by child index.
-	* @param {number} index The zero-based child index.
-	* @returns {FDocumentElement} The top-level child element wrapper.
+	* Returns the section content range, excluding its terminating section-break token.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(element);
+	* console.log(fDocument?.getSection(0)?.getRange());
 	* ```
 	*/
-	getElement(index) {
-		var _this$getElements$ind;
-		return (_this$getElements$ind = this.getElements()[index]) !== null && _this$getElements$ind !== void 0 ? _this$getElements$ind : null;
+	getRange() {
+		const sectionBreaks = getTopLevelSectionBreaks(this._document.getBody());
+		const { index, sectionBreak } = this._resolve();
+		return {
+			startOffset: index === 0 ? 0 : sectionBreaks[index - 1].startIndex + 1,
+			endOffset: sectionBreak.startIndex,
+			segmentId: ""
+		};
 	}
 	/**
-	* Get the current child index of an element handle.
-	* The index is resolved from the element key, so a paragraph handle keeps pointing
-	* to the same paragraph after facade edits insert content before it.
-	* @param {FDocumentElement} element The element handle to locate.
-	* @returns {number} The current zero-based child index.
+	* Returns the explicit columns. An empty array means the normal single-column layout.
+	* Column widths and trailing spaces are in points (pt).
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* console.log(fDocumentBody.getElementIndex(element));
+	* console.log(fDocument?.getSection(0)?.getColumns());
 	* ```
 	*/
-	getElementIndex(element) {
-		const { type, key } = element.getResolvedInfo();
-		const index = this._getChildren().findIndex((child) => child.type === type && child.key === key);
-		if (index < 0) throw new Error("Doc element is stale");
-		return index;
+	getColumns() {
+		var _this$getConfig$colum;
+		return Tools.deepClone((_this$getConfig$colum = this.getConfig().columnProperties) !== null && _this$getConfig$colum !== void 0 ? _this$getConfig$colum : []);
 	}
 	/**
-	* Insert plain text at a document body offset.
-	* @param {number} index The zero-based insertion offset.
-	* @param {string} text The plain text to insert.
-	* @returns {boolean} `true` if the edit was applied.
+	* Returns a compact serializable section summary.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* fDocumentBody.insertText(0, 'Hello ');
+	* console.log(fDocument?.getSection(0)?.describe());
 	* ```
 	*/
-	insertText(index, text) {
-		return this._replaceBodyRange({
-			startOffset: index,
-			endOffset: index
-		}, buildPlainTextInsertBody(text));
+	describe() {
+		var _config$columnPropert, _config$columnSeparat, _config$sectionType;
+		const config = this.getConfig();
+		const columns = (_config$columnPropert = config.columnProperties) !== null && _config$columnPropert !== void 0 ? _config$columnPropert : [];
+		const headerFooter = {
+			defaultHeader: this._describeHeaderFooterReference("header", "default"),
+			defaultFooter: this._describeHeaderFooterReference("footer", "default"),
+			firstHeader: this._describeHeaderFooterReference("header", "first"),
+			firstFooter: this._describeHeaderFooterReference("footer", "first"),
+			evenHeader: this._describeHeaderFooterReference("header", "even"),
+			evenFooter: this._describeHeaderFooterReference("footer", "even")
+		};
+		return {
+			sectionId: this._sectionId,
+			index: this.getIndex(),
+			range: this.getRange(),
+			columnCount: columns.length || 1,
+			columns: Tools.deepClone(columns),
+			columnSeparatorType: (_config$columnSeparat = config.columnSeparatorType) !== null && _config$columnSeparat !== void 0 ? _config$columnSeparat : ColumnSeparatorType.NONE,
+			sectionType: (_config$sectionType = config.sectionType) !== null && _config$sectionType !== void 0 ? _config$sectionType : SectionType.SECTION_TYPE_UNSPECIFIED,
+			headerFooter,
+			config
+		};
 	}
 	/**
-	* Apply text style to a body range.
-	* @param {IFDocumentTextRange} range The range to style.
-	* @param {ITextStyle} style The Univer text style patch.
-	* @returns {boolean} `true` if the style was applied.
+	* Sets equal or explicitly sized columns for this traditional section.
+	* Use `columnCount = 1` to restore normal single-column layout.
+	* `gap` and `widths` are in points (pt).
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* fDocumentBody.setTextStyle({ startOffset: 0, endOffset: 5 }, { bl: 1 });
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.getSection(0)?.setColumns(2, { gap: 18, separator: true });
+	* }
 	* ```
 	*/
-	setTextStyle(range, style) {
-		const updateBody = {
-			dataStream: "",
-			textRuns: [{
-				st: 0,
-				ed: range.endOffset - range.startOffset,
-				ts: style
-			}]
-		};
-		return this._retainBodyRange(range, updateBody, UpdateDocsAttributeType.COVER);
+	setColumns(columnCount, options = {}) {
+		var _options$gap, _options$separator;
+		this._assertTraditionalDocument();
+		if (!Number.isInteger(columnCount) || columnCount < 1) throw new RangeError("Section column count must be a positive integer.");
+		if (options.widths && options.widths.length !== columnCount) throw new RangeError("Section column widths must match the column count.");
+		const gap = Math.max(0, (_options$gap = options.gap) !== null && _options$gap !== void 0 ? _options$gap : 18);
+		const config = this.getConfig();
+		const columns = createSectionColumnProperties(this._document.getDocumentDataModel().getSnapshot().documentStyle, config, columnCount, gap, options.widths);
+		const separator = typeof options.separator === "boolean" ? options.separator ? ColumnSeparatorType.BETWEEN_EACH_COLUMN : ColumnSeparatorType.NONE : (_options$separator = options.separator) !== null && _options$separator !== void 0 ? _options$separator : ColumnSeparatorType.NONE;
+		return this._update({
+			columnProperties: columns,
+			columnSeparatorType: separator,
+			...options.sectionType == null ? {} : { sectionType: options.sectionType }
+		});
 	}
 	/**
-	* Insert a plain-text paragraph before the paragraph at the given paragraph index.
-	* @param {number} index The zero-based paragraph insertion index.
-	* @param {string} text The paragraph text. Defaults to an empty paragraph.
-	* @returns {FDocumentParagraph} The inserted paragraph wrapper.
+	* Sets explicit OOXML-compatible column width and trailing-space values in points (pt).
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const paragraph = fDocumentBody.insertParagraph(0, 'Document title');
-	* paragraph.appendText(' suffix');
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.getSection(0)?.setColumnProperties([
+	*     { width: 240, paddingEnd: 18 },
+	*     { width: 240, paddingEnd: 0 },
+	*   ], univerAPI.Enum.ColumnSeparatorType.BETWEEN_EACH_COLUMN);
+	* }
 	* ```
 	*/
-	insertParagraph(index, text = "") {
-		var _paragraphs;
-		const offset = this._getParagraphInsertOffset(index);
-		if (!this._replaceBodyRange({
-			startOffset: offset,
-			endOffset: offset
-		}, buildPlainTextInsertBody(`${text}\r`))) throw new Error("Failed to insert paragraph.");
-		const { paragraphs = [] } = this.getBody();
-		const paragraph = paragraphs[index];
-		if (!paragraph) throw new Error("Failed to insert paragraph.");
-		const info = this._resolveParagraphInfo(paragraph, index, (_paragraphs = paragraphs[index - 1]) === null || _paragraphs === void 0 ? void 0 : _paragraphs.startIndex);
-		return this._injector.createInstance(FDocumentParagraph, this, this._bodyEdit, info, this._injector);
+	setColumnProperties(columns, separator = ColumnSeparatorType.NONE) {
+		this._assertTraditionalDocument();
+		if (columns.some(({ width, paddingEnd }) => width < 0 || paddingEnd < 0)) throw new RangeError("Section column widths and padding must be non-negative.");
+		return this._update({
+			columnProperties: Tools.deepClone(columns),
+			columnSeparatorType: separator
+		});
 	}
 	/**
-	* Append a plain-text paragraph at the end of the body.
-	* @param {string} text The paragraph text. Defaults to an empty paragraph.
-	* @returns {FDocumentParagraph} The appended paragraph wrapper.
+	* Sets how the next section begins.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const paragraph = fDocumentBody.appendParagraph('Summary');
-	* console.log(paragraph.getText());
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.getSection(0)?.setSectionType(univerAPI.Enum.SectionType.NEXT_PAGE);
+	* }
 	* ```
 	*/
-	appendParagraph(text = "") {
-		const { paragraphs = [] } = this.getBody();
-		return this.insertParagraph(paragraphs.length, text);
+	setSectionType(sectionType) {
+		this._assertTraditionalDocument();
+		return this._update({ sectionType });
 	}
 	/**
-	* Delete a range from the body.
-	* @param {IFDocumentTextRange} range The text range to delete.
-	* @returns {boolean} `true` if the range was deleted.
+	* Ensures a header segment linked specifically to this section.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* fDocumentBody.deleteRange({ startOffset: 0, endOffset: 5 });
+	* if (fDocument && !fDocument.isModern()) {
+	*   const segmentId = fDocument.getSection(0)?.ensureHeader();
+	*   if (segmentId) {
+	*     fDocument.insertText(0, 'Quarterly report', segmentId);
+	*   }
+	* }
 	* ```
 	*/
-	deleteRange(range) {
-		return this._replaceBodyRange(range, { dataStream: "" });
+	ensureHeader(variant = "default") {
+		return this._ensureHeaderFooter("header", variant);
 	}
 	/**
-	* Remove a paragraph by paragraph id.
-	* @param {FDocumentParagraph} paragraph The paragraph handle to remove.
-	* @returns {boolean} `true` if the paragraph was removed.
+	* Ensures a footer segment linked specifically to this section.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   const removed = fDocumentBody.removeParagraph(paragraph);
-	*   console.log(removed ? 'Paragraph removed' : 'Failed to remove paragraph');
+	* if (fDocument && !fDocument.isModern()) {
+	*   const segmentId = fDocument.getSection(0)?.ensureFooter('first');
+	*   if (segmentId) {
+	*     fDocument.insertText(0, 'Confidential', segmentId);
+	*   }
 	* }
 	* ```
 	*/
-	removeParagraph(paragraph) {
-		const { startOffset, endOffset } = paragraph.getResolvedParagraphInfo();
-		return this.deleteRange({
-			startOffset,
-			endOffset: endOffset + 1
-		});
+	ensureFooter(variant = "default") {
+		return this._ensureHeaderFooter("footer", variant);
 	}
 	/**
-	* Remove a callout, quote, or code block range and its content.
-	* @param {FDocumentBlockRange} blockRange The block range handle to remove.
-	* @returns {boolean} `true` if the block range content was removed.
+	* Returns the effective header id after resolving links to previous sections.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isBlockRange()) {
-	*   const blockRange = element.asBlockRange();
-	*   const removed = fDocumentBody.removeBlockRange(blockRange);
-	*   console.log(removed ? 'Block range removed' : 'Failed to remove block range');
+	* console.log(fDocument?.getSection(0)?.getHeaderId('default'));
+	* ```
+	*/
+	getHeaderId(variant = "default") {
+		var _this$_getHeaderFoote;
+		return (_this$_getHeaderFoote = this._getHeaderFooterReference("header", variant).segmentId) !== null && _this$_getHeaderFoote !== void 0 ? _this$_getHeaderFoote : null;
+	}
+	/**
+	* Returns the effective footer id after resolving links to previous sections.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* console.log(fDocument?.getSection(0)?.getFooterId('first'));
+	* ```
+	*/
+	getFooterId(variant = "default") {
+		var _this$_getHeaderFoote2;
+		return (_this$_getHeaderFoote2 = this._getHeaderFooterReference("footer", variant).segmentId) !== null && _this$_getHeaderFoote2 !== void 0 ? _this$_getHeaderFoote2 : null;
+	}
+	/**
+	* Whether this header variant inherits the previous section's reference.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* console.log(fDocument?.getSection(1)?.isHeaderLinkedToPrevious());
+	* ```
+	*/
+	isHeaderLinkedToPrevious(variant = "default") {
+		return this._getHeaderFooterReference("header", variant).linkedToPrevious;
+	}
+	/**
+	* Whether this footer variant inherits the previous section's reference.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* console.log(fDocument?.getSection(1)?.isFooterLinkedToPrevious('even'));
+	* ```
+	*/
+	isFooterLinkedToPrevious(variant = "default") {
+		return this._getHeaderFooterReference("footer", variant).linkedToPrevious;
+	}
+	/**
+	* Links or unlinks this header variant. Unlinking clones the inherited header.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.getSection(1)?.setHeaderLinkedToPrevious(false, 'default');
 	* }
 	* ```
 	*/
-	removeBlockRange(blockRange) {
-		const { startIndex, endIndex } = blockRange.getBlockRange();
-		return this.deleteRange({
-			startOffset: startIndex,
-			endOffset: endIndex + 1
-		});
+	setHeaderLinkedToPrevious(linkedToPrevious, variant = "default") {
+		return this._setHeaderFooterLinkedToPrevious("header", variant, linkedToPrevious);
 	}
 	/**
-	* Remove a table marker and its content range.
-	* @returns {boolean} `true` if the table range was removed.
+	* Links or unlinks this footer variant. Unlinking clones the inherited footer.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isTable()) {
-	*   const table = element.asTable();
-	*   const removed = fDocumentBody.removeTable(table);
-	*   console.log(removed ? 'Table removed' : 'Failed to remove table');
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.getSection(1)?.setFooterLinkedToPrevious(true, 'even');
 	* }
 	* ```
 	*/
-	removeTable(table) {
-		const { startIndex, endIndex } = table.getTable();
-		return this.deleteRange({
-			startOffset: startIndex,
-			endOffset: endIndex + 1
-		});
+	setFooterLinkedToPrevious(linkedToPrevious, variant = "default") {
+		return this._setHeaderFooterLinkedToPrevious("footer", variant, linkedToPrevious);
 	}
 	/**
-	* Remove a custom block marker and its placeholder character.
-	* @param {FDocumentCustomBlock} customBlock The custom block handle to remove.
-	* @returns {boolean} `true` if the custom block placeholder was removed.
+	* Updates header/footer switches and margins on this section break.
+	* `marginHeader` and `marginFooter` are in points (pt).
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isCustomBlock()) {
-	*   const customBlock = element.asCustomBlock();
-	*   const removed = fDocumentBody.removeCustomBlock(customBlock);
-	*   console.log(removed ? 'Custom block removed' : 'Failed to remove custom block');
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.getSection(0)?.setHeaderFooterOptions({
+	*     marginHeader: 36,
+	*     marginFooter: 36,
+	*     useFirstPageHeaderFooter: univerAPI.Enum.BooleanNumber.TRUE,
+	*   });
 	* }
 	* ```
 	*/
-	removeCustomBlock(customBlock) {
-		const { startIndex } = customBlock.getCustomBlock();
-		return this.deleteRange({
-			startOffset: startIndex,
-			endOffset: startIndex + 1
-		});
+	setHeaderFooterOptions(options) {
+		this._assertTraditionalDocument();
+		return this._update(options);
 	}
 	/**
-	* Resolve an element key to its current child metadata.
-	* @param {FDocumentElement} element The element handle to resolve.
-	* @returns {IFDocumentElementInfo} The current child metadata used by the facade.
+	* Deletes this section break. The final top-level section break cannot be removed.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	* const resolved = fDocumentBody.resolveElement(element);
-	* console.log(resolved);
-	* ```
-	*/
-	resolveElement(element) {
-		const { type, key } = element.getResolvedInfo();
-		const child = this._getChildren().find((item) => item.type === type && item.key === key);
-		if (!child) throw new Error("Doc element is stale");
-		return child;
-	}
-	_getChildren() {
-		const { paragraphs, blockRanges, tables, customBlocks } = this.getBody();
-		const children = [];
-		if (paragraphs) for (let i = 0; i < paragraphs.length; i++) {
-			var _paragraphs2;
-			const paragraph = paragraphs[i];
-			const info = this._resolveParagraphInfo(paragraph, i, (_paragraphs2 = paragraphs[i - 1]) === null || _paragraphs2 === void 0 ? void 0 : _paragraphs2.startIndex);
-			children.push(info);
-		}
-		if (blockRanges) for (let i = 0; i < blockRanges.length; i++) {
-			const blockRange = blockRanges[i];
-			children.push({
-				type: DocumentBlockType.BLOCK_RANGE,
-				key: blockRange.blockId,
-				position: blockRange.startIndex,
-				priority: 0
-			});
-		}
-		if (tables) for (let i = 0; i < tables.length; i++) {
-			const table = tables[i];
-			children.push({
-				type: DocumentBlockType.TABLE,
-				key: table.tableId,
-				position: table.startIndex,
-				priority: 1
-			});
-		}
-		if (customBlocks) for (let i = 0; i < customBlocks.length; i++) {
-			const customBlock = customBlocks[i];
-			children.push({
-				type: DocumentBlockType.CUSTOM_BLOCK,
-				key: customBlock.blockId,
-				position: customBlock.startIndex,
-				priority: 2
-			});
-		}
-		return children.sort((a, b) => a.position - b.position || a.priority - b.priority);
+	* if (fDocument && !fDocument.isModern()) {
+	*   const sections = fDocument.getSections();
+	*   if (sections.length > 1) {
+	*     sections[0].remove();
+	*   }
+	* }
+	* ```
+	*/
+	remove() {
+		this._assertTraditionalDocument();
+		return this._injector.get(ICommandService).syncExecuteCommand(DeleteDocumentSectionBreakCommand.id, {
+			unitId: this._document.getId(),
+			sectionId: this._sectionId
+		});
 	}
-	_resolveParagraphInfo(paragraph, paragraphIndex, previousParagraphStartIndex) {
+	_update(patch) {
+		const { sectionId: _sectionId, startIndex: _startIndex, ...config } = patch;
+		return this._injector.get(ICommandService).syncExecuteCommand(UpdateDocumentSectionCommand.id, {
+			unitId: this._document.getId(),
+			updates: [{
+				sectionId: this._sectionId,
+				config
+			}]
+		});
+	}
+	_ensureHeaderFooter(kind, variant) {
+		this._assertTraditionalDocument();
+		const { index } = this._resolve();
+		const existing = this.getConfig()[getSectionHeaderFooterReferenceKey(kind, variant)];
+		if (typeof existing === "string" && existing) return existing;
+		if (index > 0) {
+			const segmentId = generateRandomId(6);
+			if (!this._injector.get(ICommandService).syncExecuteCommand(SetSectionHeaderFooterLinkCommand.id, {
+				unitId: this._document.getId(),
+				sectionId: this._sectionId,
+				kind,
+				variant,
+				linkedToPrevious: false,
+				segmentId
+			})) throw new Error(`Failed to create section ${kind}.`);
+			return segmentId;
+		}
+		const types = {
+			default: kind === "header" ? HeaderFooterType.DEFAULT_HEADER : HeaderFooterType.DEFAULT_FOOTER,
+			first: kind === "header" ? HeaderFooterType.FIRST_PAGE_HEADER : HeaderFooterType.FIRST_PAGE_FOOTER,
+			even: kind === "header" ? HeaderFooterType.EVEN_PAGE_HEADER : HeaderFooterType.EVEN_PAGE_FOOTER
+		};
+		const segmentId = generateRandomId(6);
+		if (!this._injector.get(ICommandService).syncExecuteCommand(CreateHeaderFooterCommand.id, {
+			unitId: this._document.getId(),
+			segmentId,
+			createType: types[variant],
+			sectionId: this._sectionId
+		})) throw new Error(`Failed to create section ${kind}.`);
+		return segmentId;
+	}
+	_getHeaderFooterReference(kind, variant) {
+		const { index } = this._resolve();
+		return resolveSectionHeaderFooterReference(this._document.getDocumentDataModel().getSnapshot().documentStyle, getTopLevelSectionBreaks(this._document.getBody()), index, getSectionHeaderFooterReferenceKey(kind, variant));
+	}
+	_describeHeaderFooterReference(kind, variant) {
+		var _reference$segmentId;
+		const reference = this._getHeaderFooterReference(kind, variant);
 		return {
-			type: DocumentBlockType.PARAGRAPH,
-			key: this._getParagraphId(paragraph, paragraphIndex),
-			position: paragraphIndex > 0 ? previousParagraphStartIndex + 1 : 0,
-			priority: 3
+			segmentId: (_reference$segmentId = reference.segmentId) !== null && _reference$segmentId !== void 0 ? _reference$segmentId : null,
+			linkedToPrevious: reference.linkedToPrevious
 		};
 	}
-	_getParagraphId(paragraph, paragraphIndex) {
-		if (!paragraph) throw new Error(`Paragraph index ${paragraphIndex} is out of range.`);
-		if (!paragraph.paragraphId) throw new Error(`Paragraph at index ${paragraphIndex} is missing paragraphId.`);
-		return paragraph.paragraphId;
-	}
-	_getParagraphInsertOffset(index) {
-		if (index <= 0) return 0;
-		const { dataStream, paragraphs = [] } = this.getBody();
-		if (paragraphs.length === 0) return Math.max(0, dataStream.length - 1);
-		if (index >= paragraphs.length) return paragraphs[paragraphs.length - 1].startIndex + 1;
-		return paragraphs[index - 1].startIndex + 1;
-	}
-	_replaceBodyRange(range, insertBody) {
-		const { startOffset, endOffset } = range;
-		const textX = new TextX();
-		if (startOffset > 0) textX.push({
-			t: TextXActionType.RETAIN,
-			len: startOffset
-		});
-		if (endOffset > startOffset) textX.push({
-			t: TextXActionType.DELETE,
-			len: endOffset - startOffset
-		});
-		if (insertBody.dataStream.length > 0) textX.push({
-			t: TextXActionType.INSERT,
-			body: insertBody,
-			len: insertBody.dataStream.length
-		});
-		return this._executeTextX(textX);
-	}
-	_retainBodyRange(range, body, coverType) {
-		var _body$textRuns;
-		if (((_body$textRuns = body.textRuns) === null || _body$textRuns === void 0 ? void 0 : _body$textRuns.length) && this.getBody().textRuns == null) this._ensureTextRuns();
-		const textX = new TextX();
-		if (range.startOffset > 0) textX.push({
-			t: TextXActionType.RETAIN,
-			len: range.startOffset
+	_setHeaderFooterLinkedToPrevious(kind, variant, linkedToPrevious) {
+		this._assertTraditionalDocument();
+		return this._injector.get(ICommandService).syncExecuteCommand(SetSectionHeaderFooterLinkCommand.id, {
+			unitId: this._document.getId(),
+			sectionId: this._sectionId,
+			kind,
+			variant,
+			linkedToPrevious,
+			...linkedToPrevious ? {} : { segmentId: generateRandomId(6) }
 		});
-		textX.push({
-			t: TextXActionType.RETAIN,
-			body,
-			coverType,
-			len: range.endOffset - range.startOffset
-		});
-		return this._executeTextX(textX);
 	}
-	_ensureTextRuns() {
-		const actions = JSONX.getInstance().replaceOp([...getRichTextEditPath(this._documentDataModel, this._segmentId), "textRuns"], void 0, []);
-		this._injector.get(ICommandService).syncExecuteCommand(RichTextEditingMutation.id, {
-			unitId: this._documentDataModel.getUnitId(),
-			segmentId: this._segmentId,
-			actions,
-			textRanges: [],
-			isEditing: false
-		});
+	_assertTraditionalDocument() {
+		if (this._document.getDocumentDataModel().getSnapshot().documentStyle.documentFlavor !== DocumentFlavor.TRADITIONAL) throw new DocsSectionUnsupportedDocumentFlavorError();
 	}
-	_executeTextX(textX) {
-		const actions = JSONX.getInstance().editOp(textX.serialize(), getRichTextEditPath(this._documentDataModel, this._segmentId));
-		return this._injector.get(ICommandService).syncExecuteCommand(RichTextEditingMutation.id, {
-			unitId: this._documentDataModel.getUnitId(),
-			segmentId: this._segmentId,
-			actions,
-			textRanges: [],
-			isEditing: false
-		}) !== false;
+	_resolve() {
+		this._assertTraditionalDocument();
+		const sectionBreaks = getTopLevelSectionBreaks(this._document.getBody());
+		const index = sectionBreaks.findIndex((section) => section.sectionId === this._sectionId);
+		if (index < 0) throw new Error(`Document section with id ${this._sectionId} not found.`);
+		return {
+			index,
+			sectionBreak: sectionBreaks[index]
+		};
 	}
 };
 
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
 //#endregion
 //#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
@@ -1026,42 +1062,42 @@ let FDocument = class FDocument extends FBaseInitialable {
 	}
 	/**
 	* Get the document data model of the document.
+	* @param {string} segmentId The segment id used to get the header/footer data model. Defaults to an empty string for the document data model of the document.
 	* @returns {DocumentDataModel} The document data model.
 	* @example
 	* ```typescript
 	* const fDocument = univerAPI.getActiveDocument();
-	* const documentDataModel = fDocument.getDocumentDataModel();
-	* console.log(documentDataModel);
+	* console.log(fDocument.getDocumentDataModel());
+	*
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* console.log(fDocument.getDocumentDataModel(headerSegmentId));
 	* ```
 	*/
-	getDocumentDataModel() {
-		return this._documentDataModel;
+	getDocumentDataModel(segmentId = "") {
+		const documentDataModel = this._documentDataModel.getSelfOrHeaderFooterModel(segmentId);
+		if (!documentDataModel) throw new Error(segmentId === "" ? "Document data model is not found." : `Document data model is not found in the segment: ${segmentId}`);
+		return documentDataModel;
 	}
 	/**
-	* Get the document body facade.
-	*
-	* The returned body facade provides synchronous Google Docs-like element APIs
-	* for reading and editing top-level document body elements. Paragraph elements
-	* use their persisted `paragraphId` values. Persisted elements, such as tables
-	* and custom blocks, use their existing ids.
-	*
-	* @returns {FDocumentBody} The document body API instance.
+	* Get the document body or header/footer body by the segment id.
+	* The main body has an empty segment id.
+	* The header and footer body have their respective segment ids.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {IDocumentBody} The document body.
 	* @example
 	* ```typescript
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* console.log(fDocumentBody.getBody());
+	* console.log(fDocument.getBody()); // Get the main body
 	*
-	* const element = fDocumentBody.getElement(0);
-	* if (element.isParagraph()) {
-	*   const paragraph = element.asParagraph();
-	*   paragraph.appendText(' updated');
-	*   console.log(paragraph.getText());
-	* }
+	* const footerSegmentId = fDocument.ensurePageFooter();
+	* console.log(fDocument.getBody(footerSegmentId)); // Get the footer body
 	* ```
 	*/
-	getBody() {
-		return this._injector.createInstance(FDocumentBody, this._documentDataModel, this._injector);
+	getBody(segmentId = "") {
+		var _this$_documentDataMo;
+		const body = (_this$_documentDataMo = this._documentDataModel.getSelfOrHeaderFooterModel(segmentId)) === null || _this$_documentDataMo === void 0 ? void 0 : _this$_documentDataMo.getBody();
+		if (!body) throw new Error(segmentId === "" ? "Body is not found in the document." : `Body is not found in the segment: ${segmentId}`);
+		return body;
 	}
 	dispose() {
 		super.dispose();
@@ -1072,8 +1108,7 @@ let FDocument = class FDocument extends FBaseInitialable {
 	* @example
 	* ```typescript
 	* const fDocument = univerAPI.getActiveDocument();
-	* const unitId = fDocument.getId();
-	* console.log(unitId);
+	* console.log(fDocument.getId());
 	* ```
 	*/
 	getId() {
@@ -1085,14 +1120,25 @@ let FDocument = class FDocument extends FBaseInitialable {
 	* @example
 	* ```typescript
 	* const fDocument = univerAPI.getActiveDocument();
-	* const name = fDocument.getName();
-	* console.log(name);
+	* console.log(fDocument.getName());
 	* ```
 	*/
 	getName() {
 		return this._documentDataModel.getTitle() || "";
 	}
 	/**
+	* Whether the document is a modern document or not.
+	* @returns {boolean} `true` if the document is a modern document, or `false` if it is not.
+	* @example
+	* ```typescript
+	* const fDocument = univerAPI.getActiveDocument();
+	* console.log(fDocument.isModern());
+	* ```
+	*/
+	isModern() {
+		return this._documentDataModel.getSnapshot().documentStyle.documentFlavor === DocumentFlavor.MODERN;
+	}
+	/**
 	* Save the document snapshot data, including the document content and resource data, etc.
 	* @returns {IDocumentData} The document snapshot data.
 	* @example
@@ -1133,264 +1179,505 @@ let FDocument = class FDocument extends FBaseInitialable {
 		this._univerInstanceService.focusUnit(this.id);
 		return this._commandService.syncExecuteCommand(RedoCommand.id);
 	}
-};
-FDocument = __decorate([
-	__decorateParam(1, Inject(Injector)),
-	__decorateParam(2, IUniverInstanceService),
-	__decorateParam(3, Inject(IResourceLoaderService)),
-	__decorateParam(4, ICommandService)
-], FDocument);
-
-//#endregion
-//#region src/facade/f-univer.ts
-var FUniverDocsMixin = class extends FUniver {
-	createDocument(data) {
-		const document = this._injector.get(IUniverInstanceService).createUnit(UniverInstanceType.UNIVER_DOC, data);
-		return this._injector.createInstance(FDocument, document);
+	/**
+	* Ensure the page header segment exists and return its segment id.
+	* @param {number} pageIndex The zero-based page index. Defaults to the first page.
+	* @returns {string} The header segment id.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* fDocument.insertText(0, 'Header text', headerSegmentId);
+	* ```
+	*/
+	ensurePageHeader(pageIndex = 0) {
+		return this._ensureHeaderFooter("header", pageIndex);
 	}
-	getActiveDocument() {
-		const document = this._univerInstanceService.getCurrentUnitOfType(UniverInstanceType.UNIVER_DOC);
-		if (!document) return null;
-		return this._injector.createInstance(FDocument, document);
+	/**
+	* Ensure the page footer segment exists and return its segment id.
+	* @param {number} pageIndex The zero-based page index. Defaults to the first page.
+	* @returns {string} The footer segment id.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const footerSegmentId = fDocument.ensurePageFooter();
+	* fDocument.insertText(0, 'Footer text', footerSegmentId);
+	* ```
+	*/
+	ensurePageFooter(pageIndex = 0) {
+		return this._ensureHeaderFooter("footer", pageIndex);
 	}
-	getDocument(id) {
-		const document = this._univerInstanceService.getUnit(id, UniverInstanceType.UNIVER_DOC);
-		if (!document) return null;
-		return this._injector.createInstance(FDocument, document);
+	/**
+	* Insert plain text at a document body offset.
+	* @param {number} index The zero-based insertion offset.
+	* @param {string} text The plain text to insert.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {boolean} `true` if the edit was applied.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* fDocument.insertText(0, 'Hello ');
+	*
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* fDocument.insertText(0, 'Header text', headerSegmentId);
+	* ```
+	*/
+	insertText(index, text, segmentId = "") {
+		return replaceBodyRange({
+			startOffset: index,
+			endOffset: index,
+			segmentId
+		}, buildPlainTextInsertBody(text), this._documentDataModel, this._injector);
 	}
-};
-FUniver.extend(FUniverDocsMixin);
-
-//#endregion
-//#region src/facade/f-document-block-range.ts
-/**
-* A facade wrapper for document block ranges, such as callout, quote, and code blocks.
-*
-* Block range identity is backed by the persisted `IDocumentBlockRange.blockId`,
-* so wrappers can be re-resolved after text is inserted before the block range.
-*
-* @hideconstructor
-*/
-var FDocumentBlockRange = class extends FDocumentElement {
-	constructor(body, bodyEdit, info, injector) {
-		super(body, bodyEdit, info, injector);
-		this.body = body;
-		this.bodyEdit = bodyEdit;
-		this.info = info;
-		this.injector = injector;
-		if (this.getType() !== DocumentBlockType.BLOCK_RANGE) throw new Error(`Element type is not a block range: ${this.getType()}`);
+	/**
+	* Returns document-level header/footer switches and margins. Margin values are in points (pt).
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* console.log(fDocument?.getHeaderFooterOptions());
+	* ```
+	*/
+	getHeaderFooterOptions() {
+		const style = this._documentDataModel.getSnapshot().documentStyle;
+		return {
+			marginHeader: style.marginHeader,
+			marginFooter: style.marginFooter,
+			useFirstPageHeaderFooter: style.useFirstPageHeaderFooter,
+			evenAndOddHeaders: style.evenAndOddHeaders
+		};
 	}
 	/**
-	* Get the top-level block range data model.
-	* @returns {IDocumentBlockRange} The block range data model.
+	* Updates document-level header/footer switches and margins in a traditional document.
+	* `marginHeader` and `marginFooter` are in points (pt).
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isBlockRange()) {
-	*   const blockRange = element.asBlockRange();
-	*   console.log(blockRange.getBlockRange());
+	* if (fDocument && !fDocument.isModern()) {
+	*   fDocument.setHeaderFooterOptions({ marginHeader: 36, marginFooter: 36 });
 	* }
 	* ```
 	*/
-	getBlockRange() {
-		const { blockRanges = [] } = this._body.getBody();
-		const blockRange = blockRanges.find((blockRange) => blockRange.blockId === this.getKey());
-		if (!blockRange) throw new Error(`Block range not found: ${this.getKey()}`);
-		return blockRange;
+	setHeaderFooterOptions(options) {
+		if (this.isModern()) throw new Error("The document is a modern document, header/footer is not supported.");
+		return this._commandService.syncExecuteCommand(CreateHeaderFooterCommand.id, {
+			unitId: this.getId(),
+			headerFooterProps: options
+		});
 	}
 	/**
-	* Get the block range type.
-	* @returns {DocumentBlockRangeType} The block type, such as callout, quote, or code.
+	* Creates a facade for reading and styling a document text range.
+	* The end offset is exclusive, and offsets are scoped to the selected body segment.
+	* @param {number} startOffset The inclusive start offset.
+	* @param {number} endOffset The exclusive end offset.
+	* @param {string} segmentId The header/footer segment id, or an empty string for the main body.
+	* @returns {FDocumentTextRange} A fixed text-range facade.
+	* @example
+	* ```ts
+	* const range = univerAPI.getActiveDocument()?.getTextRange(0, 5);
+	* console.log(range?.describe());
+	* range?.setTextStyle({ bl: 1 });
+	* ```
+	*/
+	getTextRange(startOffset, endOffset, segmentId = "") {
+		return this._injector.createInstance(FDocumentTextRange, this, startOffset, endOffset, segmentId, this._injector);
+	}
+	/**
+	* Returns traditional document sections backed by persisted SectionBreak ids.
+	* Modern documents use ColumnGroup instead and return an empty array from this read API.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isBlockRange()) {
-	*   const blockRange = element.asBlockRange();
-	*   console.log(blockRange.getBlockType());
-	* }
+	* const sections = fDocument?.getSections() ?? [];
+	* console.log(sections.map((section) => section.describe()));
 	* ```
 	*/
-	getBlockType() {
-		return this.getBlockRange().blockType;
+	getSections() {
+		if (this._documentDataModel.getSnapshot().documentStyle.documentFlavor !== DocumentFlavor.TRADITIONAL) return [];
+		return getTopLevelSectionBreaks(this.getBody()).map((sectionBreak) => this._injector.createInstance(FDocumentSection, this, sectionBreak.sectionId, this._injector));
 	}
 	/**
-	* Get the plain text inside this block range.
-	* @returns {string} The block range text.
+	* Returns a traditional section by zero-based index, or `null` in modern documents.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isBlockRange()) {
-	*   const blockRange = element.asBlockRange();
-	*   console.log(blockRange.getText());
+	* const firstSection = fDocument?.getSection(0);
+	* console.log(firstSection?.describe());
+	* ```
+	*/
+	getSection(index) {
+		var _this$getSections$ind;
+		return (_this$getSections$ind = this.getSections()[index]) !== null && _this$getSections$ind !== void 0 ? _this$getSections$ind : null;
+	}
+	/**
+	* Returns the traditional section containing a data-stream offset, or `null` in modern documents.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument?.findParagraphByText('Launch');
+	* const offset = paragraph?.getInfo().startOffset;
+	* const section = offset == null ? null : fDocument?.getSectionAt(offset);
+	* console.log(section?.getId());
+	* ```
+	*/
+	getSectionAt(offset) {
+		var _this$getSections$fin;
+		return (_this$getSections$fin = this.getSections().find((section) => {
+			const range = section.getRange();
+			return offset >= range.startOffset && offset <= range.endOffset;
+		})) !== null && _this$getSections$fin !== void 0 ? _this$getSections$fin : null;
+	}
+	/**
+	* Inserts a traditional document section break and returns its stable facade.
+	* Modern documents must use ColumnGroup and throw `DocsSectionUnsupportedDocumentFlavorError`.
+	* Numeric layout values in `config` are in points (pt).
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* if (fDocument && !fDocument.isModern()) {
+	*   const paragraph = fDocument.findParagraphByText('Appendix');
+	*   const offset = paragraph?.getInfo().startOffset;
+	*   const section = offset == null ? null : fDocument.insertSectionBreak(offset);
+	*   console.log(section?.getId());
 	* }
 	* ```
 	*/
-	getText() {
-		const { dataStream } = this._body.getBody();
-		const { startIndex, endIndex } = this.getBlockRange();
-		return dataStream.slice(startIndex, endIndex);
+	insertSectionBreak(offset, config = {}) {
+		var _this$getBody$section;
+		if (this._documentDataModel.getSnapshot().documentStyle.documentFlavor !== DocumentFlavor.TRADITIONAL) throw new DocsSectionUnsupportedDocumentFlavorError();
+		const sectionId = createSectionId(new Set(((_this$getBody$section = this.getBody().sectionBreaks) !== null && _this$getBody$section !== void 0 ? _this$getBody$section : []).map((section) => section.sectionId)));
+		return this._commandService.syncExecuteCommand(InsertDocumentSectionBreakCommand.id, {
+			unitId: this.getId(),
+			offset,
+			sectionId,
+			config
+		}) ? this._injector.createInstance(FDocumentSection, this, sectionId, this._injector) : null;
 	}
 	/**
-	* Replace the plain text inside this block range.
-	* @param {string} text The replacement text.
-	* @returns {boolean} `true` if the block range text was replaced.
+	* Inserts a column-break token in a traditional document.
+	* Modern documents must use ColumnGroup and throw `DocsSectionUnsupportedDocumentFlavorError`.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
-	*
-	* if (element?.isBlockRange()) {
-	*   const blockRange = element.asBlockRange();
-	*   blockRange.setText('Updated block text');
-	*   console.log(blockRange.getText());
+	* if (fDocument && !fDocument.isModern()) {
+	*   const paragraph = fDocument.findParagraphByText('Continue in next column');
+	*   const offset = paragraph?.getInfo().startOffset;
+	*   if (offset != null) {
+	*     fDocument.insertColumnBreak(offset);
+	*   }
 	* }
 	* ```
 	*/
-	setText(text) {
-		const blockRange = this.getBlockRange();
-		const { startIndex, endIndex } = blockRange;
-		const updateBody = buildPlainTextInsertBody(`${text}\r`);
-		updateBody.blockRanges = [{
-			...blockRange,
-			startIndex: 0,
-			endIndex: text.length
-		}];
-		return this._bodyEdit.replaceRange({
-			startOffset: startIndex,
-			endOffset: endIndex + 1
-		}, updateBody);
-	}
-	/**
-	* Remove this block range wrapper from the body.
-	*
-	* This currently removes the block range and its content, matching
-	* `remove()`.
-	*
-	* @returns {boolean} `true` if the block range content was removed.
+	insertColumnBreak(offset) {
+		if (this._documentDataModel.getSnapshot().documentStyle.documentFlavor !== DocumentFlavor.TRADITIONAL) throw new DocsSectionUnsupportedDocumentFlavorError();
+		return this.insertText(offset, DataStreamTreeTokenType.COLUMN_BREAK);
+	}
+	/**
+	* Inserts a horizontal rule using the existing paragraph `borderBottom` mechanism.
+	* The returned paragraph can be inspected or removed with normal paragraph APIs.
+	* Border width and padding are in points (pt).
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument?.findParagraphByText('Summary');
+	* const offset = paragraph?.getInfo().startOffset;
+	* const rule = offset == null ? null : fDocument?.insertHorizontalRule(offset);
+	* console.log(rule?.getId());
+	* ```
+	*/
+	insertHorizontalRule(offset, border = {
+		padding: 5,
+		color: { rgb: "#CDD0D8" },
+		width: 1,
+		dashStyle: DashStyleType.SOLID
+	}, segmentId = "") {
+		var _body$paragraphs;
+		const body = this.getBody(segmentId);
+		const paragraphs = generateParagraphs(DataStreamTreeTokenType.PARAGRAPH, void 0, border, (_body$paragraphs = body.paragraphs) === null || _body$paragraphs === void 0 ? void 0 : _body$paragraphs.map((paragraph) => paragraph.paragraphId));
+		const paragraphId = paragraphs[0].paragraphId;
+		return replaceBodyRange({
+			startOffset: offset,
+			endOffset: offset,
+			segmentId
+		}, {
+			dataStream: DataStreamTreeTokenType.PARAGRAPH,
+			paragraphs
+		}, this._documentDataModel, this._injector) ? this.getParagraph(paragraphId, segmentId) : null;
+	}
+	/**
+	* Get all paragraphs in the document body or header/footer body by the segment id.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {FDocumentParagraph[]} An array of paragraph facade instances.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
+	* const paragraphs = fDocument.getParagraphs();
+	* console.log(paragraphs);
 	*
-	* if (element?.isBlockRange()) {
-	*   const blockRange = element.asBlockRange();
-	*   const removed = blockRange.unwrap();
-	*   console.log(removed ? 'Block range removed' : 'Failed to remove block range');
-	* }
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* const headerParagraphs = fDocument.getParagraphs(headerSegmentId);
+	* console.log(headerParagraphs);
 	* ```
 	*/
-	unwrap() {
-		return this.remove();
+	getParagraphs(segmentId = "") {
+		const { paragraphs = [] } = this.getBody(segmentId);
+		return paragraphs.map((paragraph) => this._createFDocumentParagraph(paragraph.paragraphId, segmentId));
 	}
-};
-var FDocumentBlockRangeMixin = class extends FDocumentElement {
-	asBlockRange() {
-		if (this.getType() !== DocumentBlockType.BLOCK_RANGE) throw new Error(`Element type is not a block range: ${this.getType()}`);
-		return this._injector.createInstance(FDocumentBlockRange, this._body, this._bodyEdit, this.getResolvedInfo(), this._injector);
+	/**
+	* Get a paragraph by its paragraph id and segment id.
+	* @param {string} paragraphId The paragraph id.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {FDocumentParagraph | null} The paragraph facade instance, or `null` if the paragraph is not found.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument.getParagraph('paragraph-01');
+	* console.log(paragraph);
+	*
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* const headerParagraph = fDocument.getParagraph('header-paragraph-01', headerSegmentId);
+	* console.log(headerParagraph);
+	* ```
+	*/
+	getParagraph(paragraphId, segmentId = "") {
+		const { paragraphs = [] } = this.getBody(segmentId);
+		if (!paragraphs.find((paragraph) => paragraph.paragraphId === paragraphId)) return null;
+		return this._createFDocumentParagraph(paragraphId, segmentId);
 	}
-};
-FDocumentElement.extend(FDocumentBlockRangeMixin);
-
-//#endregion
-//#region src/facade/f-document-custom-block.ts
-/**
-* A facade wrapper for document top-level custom blocks.
-* @hideconstructor
-*/
-var FDocumentCustomBlock = class extends FDocumentElement {
-	constructor(body, bodyEdit, info, injector) {
-		super(body, bodyEdit, info, injector);
-		this.body = body;
-		this.bodyEdit = bodyEdit;
-		this.info = info;
-		this.injector = injector;
-		if (this.getType() !== DocumentBlockType.CUSTOM_BLOCK) throw new Error(`Element type is not a custom block: ${this.getType()}`);
+	/**
+	* Find a paragraph by its text content and segment id.
+	* @param {string} text The text content to search for.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {FDocumentParagraph | null} The paragraph facade instance, or `null` if the paragraph is not found.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument.findParagraphByText('Hello');
+	* console.log(paragraph);
+	*
+	* const footerSegmentId = fDocument.ensurePageFooter();
+	* const footerParagraph = fDocument.findParagraphByText('Page', footerSegmentId);
+	* console.log(footerParagraph);
+	* ```
+	*/
+	findParagraphByText(text, segmentId = "") {
+		return this.findParagraphs({
+			text,
+			segmentId
+		})[0] || null;
 	}
 	/**
-	* Get the custom block marker.
-	* @returns {ICustomBlock} The custom block marker.
+	* Find paragraphs by a query object, which can include text content, paragraph id, and segment id.
+	* @param {string | IFDocumentParagraphQuery} query The query object or text content to search for.
+	* @returns {FDocumentParagraph[]} An array of paragraph facade instances that match the query.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
+	* const paragraphsWithText = fDocument.findParagraphs('Hello');
+	* console.log(paragraphsWithText);
 	*
-	* if (element?.isCustomBlock()) {
-	*   const customBlock = element.asCustomBlock();
-	*   console.log(customBlock.getCustomBlock());
-	* }
+	* const paragraphsWithId = fDocument.findParagraphs({ paragraphId: 'paragraph-01' });
+	* console.log(paragraphsWithId);
+	*
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* const paragraphsWithSegment = fDocument.findParagraphs({ segmentId: headerSegmentId });
+	* console.log(paragraphsWithSegment);
 	* ```
 	*/
-	getCustomBlock() {
-		const { customBlocks = [] } = this._body.getBody();
-		const block = customBlocks.find((item) => item.blockId === this.getKey());
-		if (!block) throw new Error("Doc custom block is stale");
-		return block;
+	findParagraphs(query) {
+		const { text, paragraphId, segmentId = "" } = typeof query === "string" ? { text: query } : query;
+		return this.getParagraphs(segmentId).filter((paragraph) => {
+			if (paragraphId && paragraph.getId() !== paragraphId) return false;
+			if (text && !paragraph.getText().includes(text)) return false;
+			return true;
+		});
 	}
-};
-var FDocumentCustomBlockMixin = class extends FDocumentElement {
-	asCustomBlock() {
-		if (this.getType() !== DocumentBlockType.CUSTOM_BLOCK) throw new Error(`Element type is not a custom block: ${this.getType()}`);
-		return this._injector.createInstance(FDocumentCustomBlock, this._body, this._bodyEdit, this.getResolvedInfo(), this._injector);
+	/**
+	* Insert a plain-text paragraph before the paragraph at the given paragraph index.
+	* @param {number} index The zero-based paragraph insertion index.
+	* @param {string} text The paragraph text. Defaults to an empty paragraph.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {FDocumentParagraph} The inserted paragraph facade instance.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument.insertParagraph(0, 'Document title');
+	* paragraph.appendText(' suffix');
+	*
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* const headerParagraph = fDocument.insertParagraph(0, 'Header title', headerSegmentId);
+	* headerParagraph.appendText(' suffix');
+	* ```
+	*/
+	insertParagraph(index, text = "", segmentId = "") {
+		const offset = this._getParagraphInsertOffset(index, segmentId);
+		if (!replaceBodyRange({
+			startOffset: offset,
+			endOffset: offset,
+			segmentId
+		}, buildPlainTextInsertBody(`${text}\r`), this._documentDataModel, this._injector)) throw new Error("Failed to insert paragraph.");
+		const { paragraphs = [] } = this.getBody(segmentId);
+		const paragraph = paragraphs[index];
+		if (!paragraph) throw new Error("Failed to insert paragraph.");
+		return this._createFDocumentParagraph(paragraph.paragraphId, segmentId);
 	}
-};
-FDocumentElement.extend(FDocumentCustomBlockMixin);
-
-//#endregion
-//#region src/facade/f-document-table.ts
-/**
-* A facade wrapper for document top-level tables.
-* @hideconstructor
-*/
-var FDocumentTable = class extends FDocumentElement {
-	constructor(body, bodyEdit, info, injector) {
-		super(body, bodyEdit, info, injector);
-		this.body = body;
-		this.bodyEdit = bodyEdit;
-		this.info = info;
-		this.injector = injector;
-		if (this.getType() !== DocumentBlockType.TABLE) throw new Error(`Element type is not a table: ${this.getType()}`);
+	/**
+	* Append a plain-text paragraph at the end of the body.
+	* @param {string} text The paragraph text. Defaults to an empty paragraph.
+	* @param {string} segmentId The segment id of the body. Defaults to an empty string for the main body.
+	* @returns {FDocumentParagraph} The appended paragraph wrapper.
+	* @example
+	* ```ts
+	* const fDocument = univerAPI.getActiveDocument();
+	* const paragraph = fDocument.appendParagraph('Summary');
+	* console.log(paragraph.getText());
+	*
+	* const footerSegmentId = fDocument.ensurePageFooter();
+	* const footerParagraph = fDocument.appendParagraph('Confidential', footerSegmentId);
+	* console.log(footerParagraph.getText());
+	* ```
+	*/
+	appendParagraph(text = "", segmentId = "") {
+		const { paragraphs = [] } = this.getBody(segmentId);
+		return this.insertParagraph(paragraphs.length, text, segmentId);
 	}
 	/**
-	* Get the table marker.
-	* @returns {ICustomTable} The table marker.
+	* Delete a range from the body.
+	* @param {IFDocumentTextRange} range The text range to delete.
+	* @returns {boolean} `true` if the range was deleted.
 	* @example
 	* ```ts
 	* const fDocument = univerAPI.getActiveDocument();
-	* const fDocumentBody = fDocument.getBody();
-	* const element = fDocumentBody.getElement(0);
+	* fDocument.deleteRange({ startOffset: 0, endOffset: 5 });
 	*
-	* if (element?.isTable()) {
-	*   const table = element.asTable();
-	*   console.log(table.getTable());
-	* }
+	* const headerSegmentId = fDocument.ensurePageHeader();
+	* fDocument.deleteRange({ startOffset: 0, endOffset: 5, segmentId: headerSegmentId });
 	* ```
 	*/
-	getTable() {
-		const { tables = [] } = this._body.getBody();
-		const table = tables.find((item) => item.tableId === this.getKey());
-		if (!table) throw new Error("Doc table is stale");
-		return table;
+	deleteRange(range) {
+		const normalizedRange = this._normalizeDeleteRange(range);
+		if (normalizedRange.startOffset >= normalizedRange.endOffset) return false;
+		return replaceBodyRange(normalizedRange, { dataStream: "" }, this._documentDataModel, this._injector);
+	}
+	_createFDocumentParagraph(paragraphId, segmentId = "") {
+		return this._injector.createInstance(FDocumentParagraph, this, paragraphId, segmentId, this._injector);
+	}
+	_normalizeDeleteRange(range) {
+		const body = this.getBody(range.segmentId);
+		const protectedEndOffset = body.dataStream.endsWith("\r\n") ? Math.max(0, body.dataStream.length - 2) : body.dataStream.length;
+		const endOffset = Math.min(Math.max(range.endOffset, 0), protectedEndOffset);
+		return {
+			...range,
+			startOffset: Math.min(Math.max(range.startOffset, 0), endOffset),
+			endOffset
+		};
+	}
+	_getParagraphInsertOffset(index, segmentId = "") {
+		if (index <= 0) return 0;
+		const body = this.getBody(segmentId);
+		const { dataStream, paragraphs = [] } = body;
+		if (paragraphs.length === 0) return Math.max(0, dataStream.length - 1);
+		if (index >= paragraphs.length) return paragraphs[paragraphs.length - 1].startIndex + 1;
+		return getParagraphContentStartOffset(body, paragraphs[index]);
+	}
+	_ensureHeaderFooter(kind, pageIndex) {
+		if (this.isModern()) throw new Error("The document is a modern document, header/footer is not supported.");
+		const { createType, segmentId: existingSegmentId } = this._getHeaderFooterCreateInfo(kind, pageIndex);
+		if (existingSegmentId) return existingSegmentId;
+		const segmentId = generateRandomId(6);
+		if (!this._commandService.syncExecuteCommand(CreateHeaderFooterCommand.id, {
+			unitId: this.getId(),
+			segmentId,
+			createType
+		})) throw new Error(`Failed to create page ${kind}.`);
+		return segmentId;
+	}
+	_getHeaderFooterCreateInfo(kind, pageIndex) {
+		var _documentStyle$defaul, _documentStyle$defaul2;
+		const { documentStyle } = this._documentDataModel.getSnapshot();
+		const isFirstPage = pageIndex === 0;
+		const isEvenPage = (pageIndex + 1) % 2 === 0;
+		if (isFirstPage && documentStyle.useFirstPageHeaderFooter === BooleanNumber.TRUE) {
+			var _documentStyle$firstP, _documentStyle$firstP2;
+			return kind === "header" ? {
+				createType: HeaderFooterType.FIRST_PAGE_HEADER,
+				segmentId: (_documentStyle$firstP = documentStyle.firstPageHeaderId) !== null && _documentStyle$firstP !== void 0 ? _documentStyle$firstP : ""
+			} : {
+				createType: HeaderFooterType.FIRST_PAGE_FOOTER,
+				segmentId: (_documentStyle$firstP2 = documentStyle.firstPageFooterId) !== null && _documentStyle$firstP2 !== void 0 ? _documentStyle$firstP2 : ""
+			};
+		}
+		if (isEvenPage && documentStyle.evenAndOddHeaders === BooleanNumber.TRUE) {
+			var _documentStyle$evenPa, _documentStyle$evenPa2;
+			return kind === "header" ? {
+				createType: HeaderFooterType.EVEN_PAGE_HEADER,
+				segmentId: (_documentStyle$evenPa = documentStyle.evenPageHeaderId) !== null && _documentStyle$evenPa !== void 0 ? _documentStyle$evenPa : ""
+			} : {
+				createType: HeaderFooterType.EVEN_PAGE_FOOTER,
+				segmentId: (_documentStyle$evenPa2 = documentStyle.evenPageFooterId) !== null && _documentStyle$evenPa2 !== void 0 ? _documentStyle$evenPa2 : ""
+			};
+		}
+		return kind === "header" ? {
+			createType: HeaderFooterType.DEFAULT_HEADER,
+			segmentId: (_documentStyle$defaul = documentStyle.defaultHeaderId) !== null && _documentStyle$defaul !== void 0 ? _documentStyle$defaul : ""
+		} : {
+			createType: HeaderFooterType.DEFAULT_FOOTER,
+			segmentId: (_documentStyle$defaul2 = documentStyle.defaultFooterId) !== null && _documentStyle$defaul2 !== void 0 ? _documentStyle$defaul2 : ""
+		};
+	}
+};
+FDocument = __decorate([
+	__decorateParam(1, Inject(Injector)),
+	__decorateParam(2, IUniverInstanceService),
+	__decorateParam(3, Inject(IResourceLoaderService)),
+	__decorateParam(4, ICommandService)
+], FDocument);
+
+//#endregion
+//#region src/facade/f-univer.ts
+var FUniverDocsMixin = class extends FUniver {
+	createDocument(data) {
+		const document = this._injector.get(IUniverInstanceService).createUnit(UniverInstanceType.UNIVER_DOC, data);
+		return this._injector.createInstance(FDocument, document);
+	}
+	getActiveDocument() {
+		const document = this._univerInstanceService.getCurrentUnitOfType(UniverInstanceType.UNIVER_DOC);
+		if (!document) return null;
+		return this._injector.createInstance(FDocument, document);
+	}
+	getDocument(id) {
+		const document = this._univerInstanceService.getUnit(id, UniverInstanceType.UNIVER_DOC);
+		if (!document) return null;
+		return this._injector.createInstance(FDocument, document);
 	}
 };
-var FDocumentTableMixin = class extends FDocumentElement {
-	asTable() {
-		if (this.getType() !== DocumentBlockType.TABLE) throw new Error(`Element type is not a table: ${this.getType()}`);
-		return this._injector.createInstance(FDocumentTable, this._body, this._bodyEdit, this.getResolvedInfo(), this._injector);
+FUniver.extend(FUniverDocsMixin);
+
+//#endregion
+//#region src/facade/f-enum.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+var FDocsEnumMixin = class extends FEnum {
+	get SectionType() {
+		return SectionType;
+	}
+	get ColumnSeparatorType() {
+		return ColumnSeparatorType;
 	}
 };
-FDocumentElement.extend(FDocumentTableMixin);
+FEnum.extend(FDocsEnumMixin);
 
 //#endregion
-export { FDocument, FDocumentBlockRange, FDocumentBody, FDocumentCustomBlock, FDocumentElement, FDocumentParagraph, FDocumentTable };
+export { DocsSectionUnsupportedDocumentFlavorError, FDocsEnumMixin, FDocument, FDocumentParagraph, FDocumentSection, FDocumentTextRange, isParagraphFacade, stripBlockTokens };