@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/docx/sdtProperties.js

@@ -0,0 +1,290 @@
+import { elementToXml, findChild, getAttributeAnyPrefix, getLocalName, parseBooleanElement } from "./xmlParser.js";
+import { SdtLockSchema, narrowEnum } from "./parserEnums.js";
+//#region src/docx/sdtProperties.ts
+function parseListItems(el) {
+	const items = [];
+	for (const child of el.elements ?? []) if (child.type === "element" && (child.name === "w:listItem" || child.name?.endsWith(":listItem"))) {
+		const displayText = getAttributeAnyPrefix(child, "displayText");
+		const value = getAttributeAnyPrefix(child, "value");
+		if (displayText === null && value === null) continue;
+		items.push({
+			displayText: displayText ?? value ?? "",
+			value: value ?? displayText ?? ""
+		});
+	}
+	return items;
+}
+/**
+* Local names that always belong to one specific OOXML namespace. The
+* serializer's document root only declares the canonical `w` / `w14` /
+* `w15` prefixes, so any captured raw SDT child written under an
+* alternate prefix would replay as an undefined-prefix element (Word
+* refuses such files). We rewrite by element-local-name so an inherited
+* `<x:checkbox>` / `<y:repeatingSection>` (where `x` / `y` are bound to
+* the w14 / w15 URIs at the source's document root) always lands under
+* the canonical prefix in our output regardless of the source's prefix
+* choice.
+*/
+const W_LOCAL_NAMES = /* @__PURE__ */ new Set([
+	"alias",
+	"tag",
+	"id",
+	"lock",
+	"placeholder",
+	"docPart",
+	"showingPlcHdr",
+	"text",
+	"date",
+	"dateFormat",
+	"lid",
+	"calendar",
+	"storeMappedDataAs",
+	"dropDownList",
+	"listItem",
+	"comboBox",
+	"picture",
+	"docPartObj",
+	"docPartList",
+	"docPartCategory",
+	"docPartGallery",
+	"docPartUnique",
+	"group",
+	"equation",
+	"citation",
+	"bibliography",
+	"richText"
+]);
+const W14_LOCAL_NAMES = /* @__PURE__ */ new Set(["checkbox", "checked"]);
+const W15_LOCAL_NAMES = /* @__PURE__ */ new Set(["repeatingSection", "repeatingSectionItem"]);
+/**
+* Rewrite the captured raw `<*:sdtPr>` / `<*:sdtEndPr>` snippet so every
+* SDT-namespace element uses the canonical `w:` / `w14:` / `w15:`
+* prefix on save. The blockSdtSerializer's document root declares only
+* those three prefixes, so replaying a source snippet that uses an
+* alternate prefix (`<ns0:sdtPr>` with `xmlns:ns0` declared on the
+* source's `<w:document>`, or `<x:checkbox>` inside a canonical sdtPr)
+* would produce invalid XML in the saved DOCX — Word refuses files
+* with unresolved namespace prefixes.
+*
+* Heuristics, since fast-xml-parser does not surface namespace URIs in
+* preserveOrder mode:
+*
+* 1. If the captured wrapper element itself uses a non-`w` prefix, that
+*    prefix is taken to be bound to the WP URI (the source DOCX would
+*    otherwise be invalid) and ALL occurrences of it inside the snippet
+*    are rewritten to `w:`.
+* 2. After step 1, any remaining alt-prefix on an element whose local
+*    name is in W14_LOCAL_NAMES / W15_LOCAL_NAMES gets normalized to
+*    `w14:` / `w15:`. That handles a canonical `<w:sdtPr>` wrapper
+*    whose children inherit a non-`w14` / non-`w15` prefix from the
+*    source's document root.
+*/
+function normalizeWordPrefix(raw, source) {
+	let out = raw;
+	const name = source.name ?? "";
+	const colonIdx = name.indexOf(":");
+	if (colonIdx > 0) {
+		const sourcePrefix = name.slice(0, colonIdx);
+		if (sourcePrefix !== "w") out = rewritePrefix(out, sourcePrefix, "w");
+	}
+	out = normalizeChildrenForLocalNames(out, W_LOCAL_NAMES, "w");
+	out = normalizeChildrenForLocalNames(out, W14_LOCAL_NAMES, "w14");
+	out = normalizeChildrenForLocalNames(out, W15_LOCAL_NAMES, "w15");
+	return out;
+}
+function rewritePrefix(raw, from, to) {
+	const escaped = from.replaceAll(/[$()*+./?[\\\]^{|}]/gu, "\\$&");
+	const tagOpen = new RegExp(`<${escaped}:`, "gu");
+	const tagClose = new RegExp(`</${escaped}:`, "gu");
+	const attr = new RegExp(`(\\s)${escaped}:`, "gu");
+	return raw.replaceAll(tagOpen, `<${to}:`).replaceAll(tagClose, `</${to}:`).replaceAll(attr, `$1${to}:`);
+}
+function normalizeChildrenForLocalNames(raw, localNames, canonical) {
+	let out = raw;
+	for (const local of localNames) {
+		const escapedLocal = local.replaceAll(/[$()*+./?[\\\]^{|}]/gu, "\\$&");
+		const opener = new RegExp(`<(\\w+):${escapedLocal}\\b`, "gu");
+		const closer = new RegExp(`</(\\w+):${escapedLocal}\\b`, "gu");
+		out = out.replaceAll(opener, (_m, prefix) => prefix === canonical ? `<${prefix}:${local}` : `<${canonical}:${local}`);
+		out = out.replaceAll(closer, (_m, prefix) => prefix === canonical ? `</${prefix}:${local}` : `</${canonical}:${local}`);
+		out = rewriteOpenTagAttrPrefixes(out, canonical, local);
+	}
+	return out;
+}
+/**
+* Walk every `<canonical:local …>` open tag in `raw` and rewrite any
+* attribute-name prefix that is not already `canonical` (and not `xmlns`) to
+* `canonical`. Quoted attribute values are skipped so prefix-shaped substrings
+* inside a value (OpenDoPE payloads in `w:tag w:val="…"`, namespace URIs in
+* `xmlns:foo="…"`, etc.) are left untouched.
+*/
+function rewriteOpenTagAttrPrefixes(raw, canonical, local) {
+	const opener = `<${canonical}:${local}`;
+	const pieces = [];
+	let cursor = 0;
+	while (cursor < raw.length) {
+		const tagStart = raw.indexOf(opener, cursor);
+		if (tagStart === -1) {
+			pieces.push(raw.slice(cursor));
+			break;
+		}
+		const afterOpener = raw.codePointAt(tagStart + opener.length);
+		if (!(afterOpener === void 0 || !(afterOpener >= 48 && afterOpener <= 57 || afterOpener >= 65 && afterOpener <= 90 || afterOpener >= 97 && afterOpener <= 122 || afterOpener === 95))) {
+			pieces.push(raw.slice(cursor, tagStart + opener.length));
+			cursor = tagStart + opener.length;
+			continue;
+		}
+		pieces.push(raw.slice(cursor, tagStart + opener.length));
+		cursor = tagStart + opener.length;
+		let quote = null;
+		let atAttrNameBoundary = true;
+		while (cursor < raw.length) {
+			const ch = raw.charAt(cursor);
+			if (quote) {
+				pieces.push(ch);
+				cursor += 1;
+				if (ch === quote) {
+					quote = null;
+					atAttrNameBoundary = false;
+				}
+				continue;
+			}
+			if (ch === "\"" || ch === "'") {
+				quote = ch;
+				pieces.push(ch);
+				cursor += 1;
+				continue;
+			}
+			if (ch === ">") {
+				pieces.push(ch);
+				cursor += 1;
+				break;
+			}
+			if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+				pieces.push(ch);
+				cursor += 1;
+				atAttrNameBoundary = true;
+				continue;
+			}
+			if (atAttrNameBoundary) {
+				const tokenStart = cursor;
+				while (cursor < raw.length) {
+					const c = raw.charAt(cursor);
+					if (c === "=" || c === " " || c === "	" || c === "\n" || c === "\r" || c === "/" || c === ">") break;
+					cursor += 1;
+				}
+				const token = raw.slice(tokenStart, cursor);
+				const colonIdx = token.indexOf(":");
+				if (colonIdx > 0) {
+					const prefix = token.slice(0, colonIdx);
+					const localAttr = token.slice(colonIdx + 1);
+					if (prefix !== canonical && prefix !== "xmlns" && /^\w+$/u.test(prefix) && localAttr.length > 0) pieces.push(`${canonical}:${localAttr}`);
+					else pieces.push(token);
+				} else pieces.push(token);
+				atAttrNameBoundary = false;
+				continue;
+			}
+			pieces.push(ch);
+			cursor += 1;
+		}
+	}
+	return pieces.join("");
+}
+/**
+* Parse `<w:sdtPr>` (and optional `<w:sdtEndPr>`) into {@link SdtProperties}.
+*
+* Modeled fields drive addressing / template tooling; `rawPropertiesXml`
+* and `rawEndPropertiesXml` carry the original bytes for the serializer to
+* replay unchanged, so the projection only needs to handle what we
+* actually consume — unmodeled markers are not silently dropped.
+*/
+function parseSdtProperties(sdtPr, sdtEndPr) {
+	const props = { sdtType: "richText" };
+	if (sdtPr) {
+		props.rawPropertiesXml = normalizeWordPrefix(elementToXml(sdtPr), sdtPr);
+		for (const el of sdtPr.elements ?? []) {
+			if (el.type !== "element") continue;
+			const name = el.name ? getLocalName(el.name) : "";
+			switch (name) {
+				case "id": {
+					const raw = getAttributeAnyPrefix(el, "val");
+					if (raw !== null) {
+						const n = Number.parseInt(raw, 10);
+						if (!Number.isNaN(n)) props.id = n;
+					}
+					break;
+				}
+				case "alias": {
+					const aliasVal = getAttributeAnyPrefix(el, "val");
+					if (aliasVal !== null) props.alias = aliasVal;
+					break;
+				}
+				case "tag": {
+					const tagVal = getAttributeAnyPrefix(el, "val");
+					if (tagVal !== null) props.tag = tagVal;
+					break;
+				}
+				case "lock":
+					props.lock = narrowEnum(getAttributeAnyPrefix(el, "val"), SdtLockSchema) ?? "unlocked";
+					break;
+				case "placeholder": {
+					const docPart = findChild(el, "w", "docPart");
+					if (docPart) {
+						const phVal = getAttributeAnyPrefix(docPart, "val");
+						if (phVal !== null) props.placeholder = phVal;
+					}
+					break;
+				}
+				case "showingPlcHdr":
+					props.showingPlaceholder = parseBooleanElement(el, "w");
+					break;
+				case "text":
+					props.sdtType = "plainText";
+					break;
+				case "date": {
+					props.sdtType = "date";
+					const dateFormatEl = findChild(el, "w", "dateFormat");
+					if (dateFormatEl) {
+						const fmt = getAttributeAnyPrefix(dateFormatEl, "val");
+						if (fmt !== null) props.dateFormat = fmt;
+					}
+					const fullDate = getAttributeAnyPrefix(el, "fullDate");
+					if (fullDate !== null) props.dateValueISO = fullDate;
+					break;
+				}
+				case "dropDownList":
+				case "comboBox": {
+					props.sdtType = name === "dropDownList" ? "dropdown" : "comboBox";
+					props.listItems = parseListItems(el);
+					const lastValue = getAttributeAnyPrefix(el, "lastValue");
+					if (lastValue !== null) props.dropdownLastValue = lastValue;
+					break;
+				}
+				case "checkbox": {
+					props.sdtType = "checkbox";
+					const checked14 = findChild(el, "w14", "checked");
+					const checkedW = findChild(el, "w", "checked");
+					if (checked14) props.checked = parseBooleanElement(checked14, "w14");
+					else if (checkedW) props.checked = parseBooleanElement(checkedW, "w");
+					else props.checked = false;
+					break;
+				}
+				case "picture":
+					props.sdtType = "picture";
+					break;
+				case "docPartObj":
+				case "docPartList":
+					props.sdtType = "buildingBlockGallery";
+					break;
+				case "group":
+					props.sdtType = "group";
+					break;
+				default: break;
+			}
+		}
+	}
+	if (sdtEndPr) props.rawEndPropertiesXml = normalizeWordPrefix(elementToXml(sdtEndPr), sdtEndPr);
+	return props;
+}
+//#endregion
+export { parseSdtProperties };

package/dist/docx/sdtPropertiesPatch.d.ts

@@ -0,0 +1,16 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/sdtPropertiesPatch.d.ts
+/**
+ * Rewrite the relevant child elements of `<w:sdtPr>` so the modeled
+ * properties (checked / dateFormat / fullDate / lastValue / showingPlcHdr)
+ * agree with the raw XML before it is replayed by the serializer.
+ *
+ * Pure: returns a new string; the input is not modified.
+ */
+declare function reconcileRawSdtPr(raw: string, props: document_d_exports.SdtProperties, options?: {
+  dateFullDate?: string;
+  dropdownLastValue?: string;
+}): string;
+//#endregion
+export { reconcileRawSdtPr };

package/dist/docx/sdtPropertiesPatch.js

@@ -0,0 +1,144 @@
+//#region src/docx/sdtPropertiesPatch.ts
+const XML_ATTR_ESCAPES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&apos;"
+};
+/**
+* Escape a value for embedding in an XML attribute. Single-pass replace
+* over the five XML metacharacters (incl. apostrophe so the function
+* stays correct for `'`-delimited attributes even though this file always
+* emits double-quoted ones). Output is XML written to a DOCX zip — no
+* HTML / browser interpretation downstream.
+*/
+function escapeXmlAttr(value) {
+	return value.replace(/[&<>"']/gu, (ch) => XML_ATTR_ESCAPES[ch] ?? ch);
+}
+/**
+* Drop any `*:lastValue="…"` attribute (any namespace prefix, or
+* unprefixed) from an attribute-list string. We avoid a single greedy
+* regex with `\s+` (which lint flags as backtracking-risky) and instead
+* scan character-by-character against `lastValue=` while accepting any
+* preceding `prefix:`. Without prefix tolerance, a source DOCX that
+* binds the Word namespace under a non-`w` prefix
+* (`<ns0:dropDownList ns0:lastValue="old">`) would keep the stale
+* attribute alongside our freshly-emitted `w:lastValue` on save.
+*/
+function stripLastValueAttr(attrs) {
+	const SUFFIX = "lastValue=";
+	let out = attrs;
+	let searchFrom = 0;
+	while (searchFrom < out.length) {
+		const hitIdx = out.indexOf(SUFFIX, searchFrom);
+		if (hitIdx === -1) break;
+		let nameStart = hitIdx;
+		while (nameStart > 0 && /[A-Za-z0-9_-]/u.test(out[nameStart - 1] ?? "")) nameStart -= 1;
+		if (nameStart > 0 && out[nameStart - 1] === ":") {
+			nameStart -= 1;
+			while (nameStart > 0 && /[A-Za-z0-9_-]/u.test(out[nameStart - 1] ?? "")) nameStart -= 1;
+		}
+		if (nameStart === 0 || !/\s/u.test(out[nameStart - 1] ?? "")) {
+			searchFrom = hitIdx + 10;
+			continue;
+		}
+		const quoteIdx = hitIdx + 10;
+		const quote = out[quoteIdx];
+		if (quote !== "\"" && quote !== "'") {
+			searchFrom = hitIdx + 10;
+			continue;
+		}
+		const closeIdx = out.indexOf(quote, quoteIdx + 1);
+		if (closeIdx === -1) break;
+		out = `${out.slice(0, nameStart - 1)}${out.slice(closeIdx + 1)}`;
+		searchFrom = nameStart - 1;
+	}
+	return out;
+}
+/**
+* Replace or insert a child element inside `<w:sdtPr>...</w:sdtPr>`.
+*
+* - If a matching child already exists (by local name), the whole element
+*   is replaced verbatim by `replacement` (so attributes / payload come
+*   from the caller).
+* - Otherwise `replacement` is injected just before `</w:sdtPr>` so the
+*   element ends up as a child of sdtPr, not after it.
+*/
+function upsertSdtPrChild(raw, localName, replacement) {
+	const escaped = localName.replaceAll(/[$()*+./?[\\\]^{|}]/gu, "\\$&");
+	const selfClosing = new RegExp(`<\\w+:${escaped}\\b[^>]*\\/>`, "iu");
+	const opened = new RegExp(`<\\w+:${escaped}\\b[^>]*>[\\s\\S]*?<\\/\\w+:${escaped}>`, "iu");
+	if (selfClosing.test(raw)) return raw.replace(selfClosing, replacement);
+	if (opened.test(raw)) return raw.replace(opened, replacement);
+	const closing = /<\/(?<prefix>\w+):sdtPr>/iu;
+	const closingMatch = closing.exec(raw);
+	if (closingMatch) {
+		const closingPrefix = closingMatch.groups?.["prefix"];
+		return raw.replace(closing, `${replacement}</${closingPrefix}:sdtPr>`);
+	}
+	const selfClosingPr = /<(?<prefix>\w+):sdtPr(?<attrs>[^/>]*)\/>/iu;
+	if (selfClosingPr.test(raw)) return raw.replace(selfClosingPr, (_match, prefix, attrs) => `<${prefix}:sdtPr${attrs}>${replacement}</${prefix}:sdtPr>`);
+	return raw;
+}
+function setOrRemove(raw, localName, replacementWhenSet) {
+	if (replacementWhenSet === null) {
+		const escaped = localName.replaceAll(/[$()*+./?[\\\]^{|}]/gu, "\\$&");
+		const selfClosing = new RegExp(`<\\w+:${escaped}\\b[^>]*\\/>`, "igu");
+		const opened = new RegExp(`<\\w+:${escaped}\\b[^>]*>[\\s\\S]*?<\\/\\w+:${escaped}>`, "igu");
+		return raw.replaceAll(selfClosing, "").replaceAll(opened, "");
+	}
+	return upsertSdtPrChild(raw, localName, replacementWhenSet);
+}
+/**
+* Rewrite the relevant child elements of `<w:sdtPr>` so the modeled
+* properties (checked / dateFormat / fullDate / lastValue / showingPlcHdr)
+* agree with the raw XML before it is replayed by the serializer.
+*
+* Pure: returns a new string; the input is not modified.
+*/
+function reconcileRawSdtPr(raw, props, options = {}) {
+	let next = raw;
+	if (props.showingPlaceholder === true) next = setOrRemove(next, "showingPlcHdr", "<w:showingPlcHdr/>");
+	else if (props.showingPlaceholder === false) next = setOrRemove(next, "showingPlcHdr", null);
+	if (props.sdtType === "checkbox" && typeof props.checked === "boolean") {
+		const val = props.checked ? "1" : "0";
+		const checkedOpened = /<(?:\w+):checked\b[^>]*>[\s\S]*?<\/\w+:checked>/iu;
+		const checkedSelfClosing = /<(?:\w+):checked\b[^>]*\/>/iu;
+		if (checkedOpened.test(next)) next = next.replaceAll(/<(?<prefix>\w+):checked\b[^>]*>[\s\S]*?<\/\w+:checked>/giu, (_match, prefix) => `<${prefix}:checked ${prefix}:val="${val}"/>`);
+		else if (checkedSelfClosing.test(next)) next = next.replaceAll(/<(?<prefix>\w+):checked\b[^>]*\/>/giu, (_match, prefix) => `<${prefix}:checked ${prefix}:val="${val}"/>`);
+		else if (/<\w+:checkbox\b[^>]*>/iu.test(next)) next = next.replace(/<(?<prefix>\w+):checkbox\b[^>]*>/iu, (match, prefix) => `${match}<${prefix}:checked ${prefix}:val="${val}"/>`);
+		else next = upsertSdtPrChild(next, "checkbox", `<w14:checkbox><w14:checked w14:val="${val}"/></w14:checkbox>`);
+	}
+	if (props.sdtType === "date") {
+		const fullDate = options.dateFullDate;
+		const dateFormat = props.dateFormat;
+		if (fullDate !== void 0 || dateFormat !== void 0) {
+			const wDate = /<(?<prefix>\w+):date\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:date>/iu;
+			const wDateSelf = /<(?<prefix>\w+):date\b(?<attrs>[^/>]*)\/>/iu;
+			const fullDateAttr = fullDate !== void 0 ? ` w:fullDate="${escapeXmlAttr(fullDate)}"` : "";
+			const formatChild = dateFormat !== void 0 ? `<w:dateFormat w:val="${escapeXmlAttr(dateFormat)}"/>` : "";
+			if (wDate.test(next)) next = next.replace(wDate, (_match, prefix, matchedAttrs, inner) => {
+				let body = inner.replaceAll(/<\w+:dateFormat\b[^>]*(?:\/>|>[\s\S]*?<\/\w+:dateFormat>)/giu, "");
+				if (formatChild) body = `${formatChild}${body}`;
+				return `<${prefix}:date${fullDate !== void 0 ? fullDateAttr : matchedAttrs}>${body}</${prefix}:date>`;
+			});
+			else if (wDateSelf.test(next)) next = next.replace(wDateSelf, (_match, prefix) => `<${prefix}:date${fullDateAttr}>${formatChild}</${prefix}:date>`);
+			else next = upsertSdtPrChild(next, "date", `<w:date${fullDateAttr}>${formatChild}</w:date>`);
+		}
+	}
+	if ((props.sdtType === "dropdown" || props.sdtType === "comboBox") && options.dropdownLastValue !== void 0) {
+		const escapedValue = escapeXmlAttr(options.dropdownLastValue);
+		const opened = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:(?:dropDownList|comboBox)>/iu;
+		const selfClosing = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^/>]*)\/>/iu;
+		if (opened.test(next)) next = next.replace(opened, (_match, prefix, name, attrs, inner) => {
+			return `<${prefix}:${name}${stripLastValueAttr(attrs)} ${prefix}:lastValue="${escapedValue}">${inner}</${prefix}:${name}>`;
+		});
+		else if (selfClosing.test(next)) next = next.replace(selfClosing, (_match, prefix, name, attrs) => {
+			return `<${prefix}:${name}${stripLastValueAttr(attrs)} ${prefix}:lastValue="${escapedValue}"/>`;
+		});
+	}
+	return next;
+}
+//#endregion
+export { reconcileRawSdtPr };

package/dist/docx/sectionParser.d.ts

@@ -0,0 +1,95 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/sectionParser.d.ts
+declare function getUnserializedSectionPropertyChildNames(props: document_d_exports.SectionProperties): readonly string[] | undefined;
+/**
+ * Parse section properties (w:sectPr)
+ *
+ * @param sectPr - The w:sectPr element
+ * @returns SectionProperties object
+ */
+declare function parseSectionProperties(sectPr: XmlElement | null): document_d_exports.SectionProperties;
+/**
+ * Get page width in pixels (96 DPI)
+ *
+ * @param props - Section properties
+ * @param defaultWidth - Default width in twips (default: 12240 = 8.5 inches)
+ * @returns Width in pixels
+ */
+declare function getPageWidthPixels(props: document_d_exports.SectionProperties, defaultWidth?: number): number;
+/**
+ * Get page height in pixels (96 DPI)
+ *
+ * @param props - Section properties
+ * @param defaultHeight - Default height in twips (default: 15840 = 11 inches)
+ * @returns Height in pixels
+ */
+declare function getPageHeightPixels(props: document_d_exports.SectionProperties, defaultHeight?: number): number;
+/**
+ * Get content width (page width minus margins) in pixels
+ *
+ * @param props - Section properties
+ * @returns Content width in pixels
+ */
+declare function getContentWidthPixels(props: document_d_exports.SectionProperties): number;
+/**
+ * Get content height (page height minus margins) in pixels
+ *
+ * @param props - Section properties
+ * @returns Content height in pixels
+ */
+declare function getContentHeightPixels(props: document_d_exports.SectionProperties): number;
+/**
+ * Get margins in pixels
+ *
+ * @param props - Section properties
+ * @returns Object with all margins in pixels
+ */
+declare function getMarginsPixels(props: document_d_exports.SectionProperties): {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+  header: number;
+  footer: number;
+  gutter: number;
+};
+/**
+ * Check if section has different first page header/footer
+ */
+declare function hasDifferentFirstPage(props: document_d_exports.SectionProperties): boolean;
+/**
+ * Check if section has different odd/even page headers/footers
+ */
+declare function hasDifferentOddEven(props: document_d_exports.SectionProperties): boolean;
+/**
+ * Get effective column count (minimum 1)
+ */
+declare function getColumnCount(props: document_d_exports.SectionProperties): number;
+/**
+ * Check if section is landscape
+ */
+declare function isLandscape(props: document_d_exports.SectionProperties): boolean;
+/**
+ * Check if section has page borders
+ */
+declare function hasPageBorders(props: document_d_exports.SectionProperties): boolean;
+/**
+ * Check if section has line numbers
+ */
+declare function hasLineNumbers(props: document_d_exports.SectionProperties): boolean;
+/**
+ * Get default section properties (US Letter size, 1 inch margins)
+ */
+declare function getDefaultSectionProperties(): document_d_exports.SectionProperties;
+/**
+ * Merge section properties (later values override earlier)
+ *
+ * @param base - Base properties
+ * @param override - Override properties
+ * @returns Merged properties
+ */
+declare function mergeSectionProperties(base: document_d_exports.SectionProperties, override: document_d_exports.SectionProperties): document_d_exports.SectionProperties;
+//#endregion
+export { getColumnCount, getContentHeightPixels, getContentWidthPixels, getDefaultSectionProperties, getMarginsPixels, getPageHeightPixels, getPageWidthPixels, getUnserializedSectionPropertyChildNames, hasDifferentFirstPage, hasDifferentOddEven, hasLineNumbers, hasPageBorders, isLandscape, mergeSectionProperties, parseSectionProperties };