odf.js 1.12.0 → 1.13.0

package/dist/ns.d.cts

@@ -0,0 +1,32 @@
+//#region src/ns.d.ts
+declare const ODF_NAMESPACES: Readonly<{
+  office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0";
+  style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0";
+  text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0";
+  table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0";
+  draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0";
+  fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0";
+  svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0";
+  xlink: "http://www.w3.org/1999/xlink";
+  dc: "http://purl.org/dc/elements/1.1/";
+  meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0";
+  number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0";
+  chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0";
+  dr3d: "urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0";
+  math: "http://www.w3.org/1998/Math/MathML";
+  form: "urn:oasis:names:tc:opendocument:xmlns:form:1.0";
+  script: "urn:oasis:names:tc:opendocument:xmlns:script:1.0";
+  config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0";
+  presentation: "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0";
+  smil: "urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0";
+  anim: "urn:oasis:names:tc:opendocument:xmlns:animation:1.0";
+  xforms: "http://www.w3.org/2002/xforms";
+  xsd: "http://www.w3.org/2001/XMLSchema";
+  xsi: "http://www.w3.org/2001/XMLSchema-instance";
+  manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0";
+  db: "urn:oasis:names:tc:opendocument:xmlns:database:1.0";
+}>;
+type OdfNamespacePrefix = keyof typeof ODF_NAMESPACES;
+declare function xmlnsAttributes(prefixes: readonly OdfNamespacePrefix[]): Record<string, string>;
+//#endregion
+export { ODF_NAMESPACES, OdfNamespacePrefix, xmlnsAttributes };

package/dist/ns.d.ts

@@ -0,0 +1,32 @@
+//#region src/ns.d.ts
+declare const ODF_NAMESPACES: Readonly<{
+  office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0";
+  style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0";
+  text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0";
+  table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0";
+  draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0";
+  fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0";
+  svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0";
+  xlink: "http://www.w3.org/1999/xlink";
+  dc: "http://purl.org/dc/elements/1.1/";
+  meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0";
+  number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0";
+  chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0";
+  dr3d: "urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0";
+  math: "http://www.w3.org/1998/Math/MathML";
+  form: "urn:oasis:names:tc:opendocument:xmlns:form:1.0";
+  script: "urn:oasis:names:tc:opendocument:xmlns:script:1.0";
+  config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0";
+  presentation: "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0";
+  smil: "urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0";
+  anim: "urn:oasis:names:tc:opendocument:xmlns:animation:1.0";
+  xforms: "http://www.w3.org/2002/xforms";
+  xsd: "http://www.w3.org/2001/XMLSchema";
+  xsi: "http://www.w3.org/2001/XMLSchema-instance";
+  manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0";
+  db: "urn:oasis:names:tc:opendocument:xmlns:database:1.0";
+}>;
+type OdfNamespacePrefix = keyof typeof ODF_NAMESPACES;
+declare function xmlnsAttributes(prefixes: readonly OdfNamespacePrefix[]): Record<string, string>;
+//#endregion
+export { ODF_NAMESPACES, OdfNamespacePrefix, xmlnsAttributes };

package/dist/ns.js

@@ -0,0 +1,35 @@
+//#region src/ns.ts
+const ODF_NAMESPACES = Object.freeze({
+	office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
+	style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+	text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+	table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+	draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0",
+	fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
+	svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+	xlink: "http://www.w3.org/1999/xlink",
+	dc: "http://purl.org/dc/elements/1.1/",
+	meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
+	number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0",
+	chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0",
+	dr3d: "urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0",
+	math: "http://www.w3.org/1998/Math/MathML",
+	form: "urn:oasis:names:tc:opendocument:xmlns:form:1.0",
+	script: "urn:oasis:names:tc:opendocument:xmlns:script:1.0",
+	config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0",
+	presentation: "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0",
+	smil: "urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0",
+	anim: "urn:oasis:names:tc:opendocument:xmlns:animation:1.0",
+	xforms: "http://www.w3.org/2002/xforms",
+	xsd: "http://www.w3.org/2001/XMLSchema",
+	xsi: "http://www.w3.org/2001/XMLSchema-instance",
+	manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0",
+	db: "urn:oasis:names:tc:opendocument:xmlns:database:1.0"
+});
+function xmlnsAttributes(prefixes) {
+	const attrs = {};
+	for (const prefix of prefixes) attrs[`xmlns:${prefix}`] = ODF_NAMESPACES[prefix];
+	return attrs;
+}
+//#endregion
+export { ODF_NAMESPACES, xmlnsAttributes };

package/dist/package-io/read.cjs

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("../util/base64.cjs");
+const require_xml_parse = require("../xml/parse.cjs");
+const require_zip = require("../zip.cjs");
+//#region src/package-io/read.ts
+function parsePackage(bytes) {
+	const entries = require_zip.unzipPackage(bytes);
+	const parts = {};
+	for (const [path, partBytes] of Object.entries(entries)) if (looksLikeXml(partBytes)) {
+		const xml = new TextDecoder("utf-8").decode(partBytes);
+		parts[path] = {
+			kind: "xml",
+			nodes: require_xml_parse.parseXml(xml)
+		};
+	} else parts[path] = {
+		kind: "binary",
+		base64: require_util_base64.bytesToBase64(partBytes)
+	};
+	return { parts };
+}
+function looksLikeXml(bytes) {
+	let i = 0;
+	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) i = 3;
+	while (i < bytes.length) {
+		const b = bytes[i];
+		if (b === 32 || b === 9 || b === 10 || b === 13) {
+			i = i + 1;
+			continue;
+		}
+		return b === 60;
+	}
+	return false;
+}
+//#endregion
+exports.parsePackage = parsePackage;

package/dist/package-io/read.d.cts

@@ -0,0 +1,5 @@
+import { Package } from "../model/package.cjs";
+//#region src/package-io/read.d.ts
+declare function parsePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+//#endregion
+export { parsePackage };

package/dist/package-io/read.d.ts

@@ -0,0 +1,5 @@
+import { Package } from "../model/package.js";
+//#region src/package-io/read.d.ts
+declare function parsePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+//#endregion
+export { parsePackage };

package/dist/package-io/read.js

@@ -0,0 +1,34 @@
+import { bytesToBase64 } from "../util/base64.js";
+import { parseXml } from "../xml/parse.js";
+import { unzipPackage } from "../zip.js";
+//#region src/package-io/read.ts
+function parsePackage(bytes) {
+	const entries = unzipPackage(bytes);
+	const parts = {};
+	for (const [path, partBytes] of Object.entries(entries)) if (looksLikeXml(partBytes)) {
+		const xml = new TextDecoder("utf-8").decode(partBytes);
+		parts[path] = {
+			kind: "xml",
+			nodes: parseXml(xml)
+		};
+	} else parts[path] = {
+		kind: "binary",
+		base64: bytesToBase64(partBytes)
+	};
+	return { parts };
+}
+function looksLikeXml(bytes) {
+	let i = 0;
+	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) i = 3;
+	while (i < bytes.length) {
+		const b = bytes[i];
+		if (b === 32 || b === 9 || b === 10 || b === 13) {
+			i = i + 1;
+			continue;
+		}
+		return b === 60;
+	}
+	return false;
+}
+//#endregion
+export { parsePackage };

package/dist/package-io/write.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("../util/base64.cjs");
+const require_zip = require("../zip.cjs");
+const require_xml_build = require("../xml/build.cjs");
+//#region src/package-io/write.ts
+const MIMETYPE_PART = "mimetype";
+const MANIFEST_PART = "META-INF/manifest.xml";
+function serializePackage(pkg) {
+	const remaining = new Map(Object.entries(pkg.parts));
+	const entries = [];
+	const mimetype = remaining.get(MIMETYPE_PART);
+	if (mimetype !== void 0) {
+		entries.push([MIMETYPE_PART, {
+			bytes: partToBytes(mimetype),
+			stored: true
+		}]);
+		remaining.delete(MIMETYPE_PART);
+	}
+	const manifest = remaining.get(MANIFEST_PART);
+	if (manifest !== void 0) {
+		entries.push([MANIFEST_PART, { bytes: partToBytes(manifest) }]);
+		remaining.delete(MANIFEST_PART);
+	}
+	for (const [path, part] of remaining) entries.push([path, { bytes: partToBytes(part) }]);
+	return require_zip.zipPackage(entries);
+}
+function partToBytes(part) {
+	switch (part.kind) {
+		case "xml": return new TextEncoder().encode(require_xml_build.buildXml(part.nodes));
+		case "binary": return require_util_base64.base64ToBytes(part.base64);
+	}
+}
+//#endregion
+exports.MANIFEST_PART = MANIFEST_PART;
+exports.MIMETYPE_PART = MIMETYPE_PART;
+exports.serializePackage = serializePackage;

package/dist/package-io/write.d.cts

@@ -0,0 +1,7 @@
+import { Package } from "../model/package.cjs";
+//#region src/package-io/write.d.ts
+declare const MIMETYPE_PART = "mimetype";
+declare const MANIFEST_PART = "META-INF/manifest.xml";
+declare function serializePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+export { MANIFEST_PART, MIMETYPE_PART, serializePackage };

package/dist/package-io/write.d.ts

@@ -0,0 +1,7 @@
+import { Package } from "../model/package.js";
+//#region src/package-io/write.d.ts
+declare const MIMETYPE_PART = "mimetype";
+declare const MANIFEST_PART = "META-INF/manifest.xml";
+declare function serializePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+export { MANIFEST_PART, MIMETYPE_PART, serializePackage };

package/dist/package-io/write.js

@@ -0,0 +1,33 @@
+import { base64ToBytes } from "../util/base64.js";
+import { zipPackage } from "../zip.js";
+import { buildXml } from "../xml/build.js";
+//#region src/package-io/write.ts
+const MIMETYPE_PART = "mimetype";
+const MANIFEST_PART = "META-INF/manifest.xml";
+function serializePackage(pkg) {
+	const remaining = new Map(Object.entries(pkg.parts));
+	const entries = [];
+	const mimetype = remaining.get(MIMETYPE_PART);
+	if (mimetype !== void 0) {
+		entries.push([MIMETYPE_PART, {
+			bytes: partToBytes(mimetype),
+			stored: true
+		}]);
+		remaining.delete(MIMETYPE_PART);
+	}
+	const manifest = remaining.get(MANIFEST_PART);
+	if (manifest !== void 0) {
+		entries.push([MANIFEST_PART, { bytes: partToBytes(manifest) }]);
+		remaining.delete(MANIFEST_PART);
+	}
+	for (const [path, part] of remaining) entries.push([path, { bytes: partToBytes(part) }]);
+	return zipPackage(entries);
+}
+function partToBytes(part) {
+	switch (part.kind) {
+		case "xml": return new TextEncoder().encode(buildXml(part.nodes));
+		case "binary": return base64ToBytes(part.base64);
+	}
+}
+//#endregion
+export { MANIFEST_PART, MIMETYPE_PART, serializePackage };

package/dist/styles/properties.cjs

@@ -0,0 +1,286 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_entities = require("../xml/entities.cjs");
+const require_typed_shared_units = require("../typed/shared/units.cjs");
+const require_typed_shared_color = require("../typed/shared/color.cjs");
+let zod = require("zod");
+let document_schema_js = require("document-schema.js");
+//#region src/styles/properties.ts
+const StylePropertiesSchema = zod.z.object({
+	bold: zod.z.boolean().optional(),
+	italic: zod.z.boolean().optional(),
+	underline: zod.z.boolean().optional(),
+	strike: zod.z.boolean().optional(),
+	fontFamily: zod.z.string().optional(),
+	sizePt: zod.z.number().optional(),
+	color: document_schema_js.ColorSchema.optional(),
+	alignment: document_schema_js.AlignmentSchema.optional(),
+	spacingBeforePt: zod.z.number().optional(),
+	spacingAfterPt: zod.z.number().optional(),
+	lineSpacing: zod.z.number().optional(),
+	indentLeftPt: zod.z.number().optional(),
+	indentFirstLinePt: zod.z.number().optional()
+});
+const ATTR = {
+	fontWeight: "fo:font-weight",
+	fontStyle: "fo:font-style",
+	underlineStyle: "style:text-underline-style",
+	underlineWidth: "style:text-underline-width",
+	underlineColor: "style:text-underline-color",
+	lineThroughStyle: "style:text-line-through-style",
+	lineThroughType: "style:text-line-through-type",
+	fontFamily: "fo:font-family",
+	fontSize: "fo:font-size",
+	color: "fo:color",
+	textAlign: "fo:text-align",
+	marginTop: "fo:margin-top",
+	marginBottom: "fo:margin-bottom",
+	lineHeight: "fo:line-height",
+	marginLeft: "fo:margin-left",
+	textIndent: "fo:text-indent"
+};
+const TEXT_ATTR_NAMES = /* @__PURE__ */ new Set([
+	ATTR.fontWeight,
+	ATTR.fontStyle,
+	ATTR.underlineStyle,
+	ATTR.underlineWidth,
+	ATTR.underlineColor,
+	ATTR.lineThroughStyle,
+	ATTR.lineThroughType,
+	ATTR.fontFamily,
+	ATTR.fontSize,
+	ATTR.color
+]);
+const PARAGRAPH_ATTR_NAMES = /* @__PURE__ */ new Set([
+	ATTR.textAlign,
+	ATTR.marginTop,
+	ATTR.marginBottom,
+	ATTR.lineHeight,
+	ATTR.marginLeft,
+	ATTR.textIndent
+]);
+function attributeMap(element) {
+	const map = /* @__PURE__ */ new Map();
+	for (const attribute of element.attributes) map.set(attribute.name, attribute.value);
+	return map;
+}
+function formatPt(valuePt) {
+	return require_typed_shared_units.formatOdfLength(valuePt, "pt");
+}
+const PERCENTAGE_PATTERN = /^(-?(?:\d+(?:\.\d+)?|\.\d+))%$/;
+function parsePercentageMultiplier(value) {
+	const match = PERCENTAGE_PATTERN.exec(value);
+	if (match === null) return;
+	const numeric = match[1];
+	if (numeric === void 0) return;
+	return Number(numeric) / 100;
+}
+function formatPercentageMultiplier(multiplier) {
+	return `${multiplier * 100}%`;
+}
+function parseLineDecoration(style, companionA, companionAOnValue, companionB, companionBOnValue) {
+	if (style === void 0 && companionA === void 0 && companionB === void 0) return;
+	if (style === "solid" && (companionA === void 0 || companionA === companionAOnValue) && (companionB === void 0 || companionB === companionBOnValue)) return true;
+	if (style === "none" && companionA === void 0 && companionB === void 0) return false;
+	return "unknown";
+}
+const RISKY_STYLE_ELEMENT_ATTRS = /* @__PURE__ */ new Set(["style:master-page-name", "style:next-style-name"]);
+function parseTextProperties(element) {
+	const attrs = attributeMap(element);
+	const properties = {};
+	let hasUnknown = false;
+	for (const name of attrs.keys()) if (!TEXT_ATTR_NAMES.has(name)) hasUnknown = true;
+	const fontWeight = attrs.get(ATTR.fontWeight);
+	if (fontWeight === "bold") properties.bold = true;
+	else if (fontWeight === "normal") properties.bold = false;
+	else if (fontWeight !== void 0) hasUnknown = true;
+	const fontStyle = attrs.get(ATTR.fontStyle);
+	if (fontStyle === "italic") properties.italic = true;
+	else if (fontStyle === "normal") properties.italic = false;
+	else if (fontStyle !== void 0) hasUnknown = true;
+	const underline = parseLineDecoration(attrs.get(ATTR.underlineStyle), attrs.get(ATTR.underlineWidth), "auto", attrs.get(ATTR.underlineColor), "font-color");
+	if (underline === "unknown") hasUnknown = true;
+	else if (underline !== void 0) properties.underline = underline;
+	const strike = parseLineDecoration(attrs.get(ATTR.lineThroughStyle), attrs.get(ATTR.lineThroughType), "single", void 0, "");
+	if (strike === "unknown") hasUnknown = true;
+	else if (strike !== void 0) properties.strike = strike;
+	const fontFamily = attrs.get(ATTR.fontFamily);
+	if (fontFamily !== void 0) properties.fontFamily = fontFamily;
+	const fontSize = attrs.get(ATTR.fontSize);
+	if (fontSize !== void 0) {
+		const pt = require_typed_shared_units.parseOdfLength(fontSize);
+		if (pt === void 0) hasUnknown = true;
+		else properties.sizePt = pt;
+	}
+	const color = attrs.get(ATTR.color);
+	if (color !== void 0) {
+		const parsed = require_typed_shared_color.parseOdfColor(color);
+		if (parsed === void 0) hasUnknown = true;
+		else properties.color = parsed;
+	}
+	return {
+		properties,
+		hasUnknown
+	};
+}
+function parseParagraphProperties(element) {
+	const attrs = attributeMap(element);
+	const properties = {};
+	let hasUnknown = false;
+	for (const name of attrs.keys()) if (!PARAGRAPH_ATTR_NAMES.has(name)) hasUnknown = true;
+	const textAlign = attrs.get(ATTR.textAlign);
+	if (textAlign === "left" || textAlign === "center" || textAlign === "right" || textAlign === "justify") properties.alignment = textAlign;
+	else if (textAlign !== void 0) hasUnknown = true;
+	const marginTop = attrs.get(ATTR.marginTop);
+	if (marginTop !== void 0) {
+		const pt = require_typed_shared_units.parseOdfLength(marginTop);
+		if (pt === void 0) hasUnknown = true;
+		else properties.spacingBeforePt = pt;
+	}
+	const marginBottom = attrs.get(ATTR.marginBottom);
+	if (marginBottom !== void 0) {
+		const pt = require_typed_shared_units.parseOdfLength(marginBottom);
+		if (pt === void 0) hasUnknown = true;
+		else properties.spacingAfterPt = pt;
+	}
+	const marginLeft = attrs.get(ATTR.marginLeft);
+	if (marginLeft !== void 0) {
+		const pt = require_typed_shared_units.parseOdfLength(marginLeft);
+		if (pt === void 0) hasUnknown = true;
+		else properties.indentLeftPt = pt;
+	}
+	const textIndent = attrs.get(ATTR.textIndent);
+	if (textIndent !== void 0) {
+		const pt = require_typed_shared_units.parseOdfLength(textIndent);
+		if (pt === void 0) hasUnknown = true;
+		else properties.indentFirstLinePt = pt;
+	}
+	const lineHeight = attrs.get(ATTR.lineHeight);
+	if (lineHeight !== void 0) {
+		const multiplier = parsePercentageMultiplier(lineHeight);
+		if (multiplier === void 0) hasUnknown = true;
+		else properties.lineSpacing = multiplier;
+	}
+	return {
+		properties,
+		hasUnknown
+	};
+}
+function parseStyleElementProperties(styleElement) {
+	let properties = {};
+	let hasUnknown = false;
+	for (const attribute of styleElement.attributes) if (RISKY_STYLE_ELEMENT_ATTRS.has(attribute.name)) hasUnknown = true;
+	for (const child of styleElement.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "style:text-properties") {
+			const result = parseTextProperties(child);
+			properties = {
+				...properties,
+				...result.properties
+			};
+			if (result.hasUnknown) hasUnknown = true;
+		} else if (child.tag === "style:paragraph-properties") {
+			const result = parseParagraphProperties(child);
+			properties = {
+				...properties,
+				...result.properties
+			};
+			if (result.hasUnknown) hasUnknown = true;
+		} else hasUnknown = true;
+	}
+	return {
+		properties,
+		hasUnknown
+	};
+}
+function textPropertiesToAttributes(properties) {
+	const attributes = [];
+	if (properties.bold !== void 0) attributes.push({
+		name: ATTR.fontWeight,
+		value: properties.bold ? "bold" : "normal"
+	});
+	if (properties.italic !== void 0) attributes.push({
+		name: ATTR.fontStyle,
+		value: properties.italic ? "italic" : "normal"
+	});
+	if (properties.underline !== void 0) if (properties.underline) {
+		attributes.push({
+			name: ATTR.underlineStyle,
+			value: "solid"
+		});
+		attributes.push({
+			name: ATTR.underlineWidth,
+			value: "auto"
+		});
+		attributes.push({
+			name: ATTR.underlineColor,
+			value: "font-color"
+		});
+	} else attributes.push({
+		name: ATTR.underlineStyle,
+		value: "none"
+	});
+	if (properties.strike !== void 0) if (properties.strike) {
+		attributes.push({
+			name: ATTR.lineThroughStyle,
+			value: "solid"
+		});
+		attributes.push({
+			name: ATTR.lineThroughType,
+			value: "single"
+		});
+	} else attributes.push({
+		name: ATTR.lineThroughStyle,
+		value: "none"
+	});
+	if (properties.fontFamily !== void 0) attributes.push({
+		name: ATTR.fontFamily,
+		value: require_xml_entities.encodeXmlText(properties.fontFamily)
+	});
+	if (properties.sizePt !== void 0) attributes.push({
+		name: ATTR.fontSize,
+		value: formatPt(properties.sizePt)
+	});
+	if (properties.color !== void 0) attributes.push({
+		name: ATTR.color,
+		value: require_typed_shared_color.formatOdfColor(properties.color)
+	});
+	return attributes;
+}
+function paragraphPropertiesToAttributes(properties) {
+	const attributes = [];
+	if (properties.alignment !== void 0) attributes.push({
+		name: ATTR.textAlign,
+		value: properties.alignment
+	});
+	if (properties.spacingBeforePt !== void 0) attributes.push({
+		name: ATTR.marginTop,
+		value: formatPt(properties.spacingBeforePt)
+	});
+	if (properties.spacingAfterPt !== void 0) attributes.push({
+		name: ATTR.marginBottom,
+		value: formatPt(properties.spacingAfterPt)
+	});
+	if (properties.lineSpacing !== void 0) attributes.push({
+		name: ATTR.lineHeight,
+		value: formatPercentageMultiplier(properties.lineSpacing)
+	});
+	if (properties.indentLeftPt !== void 0) attributes.push({
+		name: ATTR.marginLeft,
+		value: formatPt(properties.indentLeftPt)
+	});
+	if (properties.indentFirstLinePt !== void 0) attributes.push({
+		name: ATTR.textIndent,
+		value: formatPt(properties.indentFirstLinePt)
+	});
+	return attributes;
+}
+//#endregion
+exports.StylePropertiesSchema = StylePropertiesSchema;
+exports.formatPercentageMultiplier = formatPercentageMultiplier;
+exports.formatPt = formatPt;
+exports.paragraphPropertiesToAttributes = paragraphPropertiesToAttributes;
+exports.parseLength = require_typed_shared_units.parseOdfLength;
+exports.parseParagraphProperties = parseParagraphProperties;
+exports.parseStyleElementProperties = parseStyleElementProperties;
+exports.parseTextProperties = parseTextProperties;
+exports.textPropertiesToAttributes = textPropertiesToAttributes;

package/dist/styles/properties.d.cts

@@ -0,0 +1,45 @@
+import { l as XmlElement, t as Attribute } from "../node-CkBWRjNR.cjs";
+import { r as parseOdfLength } from "../units-7pCiECuP.cjs";
+import { z } from "zod";
+//#region src/styles/properties.d.ts
+declare const StylePropertiesSchema: z.ZodObject<{
+  bold: z.ZodOptional<z.ZodBoolean>;
+  italic: z.ZodOptional<z.ZodBoolean>;
+  underline: z.ZodOptional<z.ZodBoolean>;
+  strike: z.ZodOptional<z.ZodBoolean>;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  sizePt: z.ZodOptional<z.ZodNumber>;
+  color: z.ZodOptional<z.ZodObject<{
+    r: z.ZodNumber;
+    g: z.ZodNumber;
+    b: z.ZodNumber;
+  }, z.core.$strip>>;
+  alignment: z.ZodOptional<z.ZodEnum<{
+    left: "left";
+    center: "center";
+    right: "right";
+    justify: "justify";
+  }>>;
+  spacingBeforePt: z.ZodOptional<z.ZodNumber>;
+  spacingAfterPt: z.ZodOptional<z.ZodNumber>;
+  lineSpacing: z.ZodOptional<z.ZodNumber>;
+  indentLeftPt: z.ZodOptional<z.ZodNumber>;
+  indentFirstLinePt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type StyleProperties = z.infer<typeof StylePropertiesSchema>;
+interface ParsedProperties {
+  properties: Partial<StyleProperties>;
+  hasUnknown: boolean;
+}
+declare function formatPt(valuePt: number): string;
+declare function formatPercentageMultiplier(multiplier: number): string;
+declare function parseTextProperties(element: XmlElement): ParsedProperties;
+declare function parseParagraphProperties(element: XmlElement): ParsedProperties;
+declare function parseStyleElementProperties(styleElement: XmlElement): {
+  properties: StyleProperties;
+  hasUnknown: boolean;
+};
+declare function textPropertiesToAttributes(properties: StyleProperties): Attribute[];
+declare function paragraphPropertiesToAttributes(properties: StyleProperties): Attribute[];
+//#endregion
+export { ParsedProperties, StyleProperties, StylePropertiesSchema, formatPercentageMultiplier, formatPt, paragraphPropertiesToAttributes, parseOdfLength as parseLength, parseParagraphProperties, parseStyleElementProperties, parseTextProperties, textPropertiesToAttributes };

package/dist/styles/properties.d.ts

@@ -0,0 +1,45 @@
+import { l as XmlElement, t as Attribute } from "../node-CkBWRjNR.js";
+import { r as parseOdfLength } from "../units-7pCiECuP.js";
+import { z } from "zod";
+//#region src/styles/properties.d.ts
+declare const StylePropertiesSchema: z.ZodObject<{
+  bold: z.ZodOptional<z.ZodBoolean>;
+  italic: z.ZodOptional<z.ZodBoolean>;
+  underline: z.ZodOptional<z.ZodBoolean>;
+  strike: z.ZodOptional<z.ZodBoolean>;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  sizePt: z.ZodOptional<z.ZodNumber>;
+  color: z.ZodOptional<z.ZodObject<{
+    r: z.ZodNumber;
+    g: z.ZodNumber;
+    b: z.ZodNumber;
+  }, z.core.$strip>>;
+  alignment: z.ZodOptional<z.ZodEnum<{
+    left: "left";
+    center: "center";
+    right: "right";
+    justify: "justify";
+  }>>;
+  spacingBeforePt: z.ZodOptional<z.ZodNumber>;
+  spacingAfterPt: z.ZodOptional<z.ZodNumber>;
+  lineSpacing: z.ZodOptional<z.ZodNumber>;
+  indentLeftPt: z.ZodOptional<z.ZodNumber>;
+  indentFirstLinePt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type StyleProperties = z.infer<typeof StylePropertiesSchema>;
+interface ParsedProperties {
+  properties: Partial<StyleProperties>;
+  hasUnknown: boolean;
+}
+declare function formatPt(valuePt: number): string;
+declare function formatPercentageMultiplier(multiplier: number): string;
+declare function parseTextProperties(element: XmlElement): ParsedProperties;
+declare function parseParagraphProperties(element: XmlElement): ParsedProperties;
+declare function parseStyleElementProperties(styleElement: XmlElement): {
+  properties: StyleProperties;
+  hasUnknown: boolean;
+};
+declare function textPropertiesToAttributes(properties: StyleProperties): Attribute[];
+declare function paragraphPropertiesToAttributes(properties: StyleProperties): Attribute[];
+//#endregion
+export { ParsedProperties, StyleProperties, StylePropertiesSchema, formatPercentageMultiplier, formatPt, paragraphPropertiesToAttributes, parseOdfLength as parseLength, parseParagraphProperties, parseStyleElementProperties, parseTextProperties, textPropertiesToAttributes };