@office-open/core 0.6.4 → 0.6.5

package/dist/patch-BdMU95aX.mjs

@@ -0,0 +1,337 @@
+import { xml2js } from "@office-open/xml";
+//#region src/patch/xml-namespace.ts
+const DOCX_NS = {
+	paragraph: "w:p",
+	run: "w:r",
+	text: "w:t",
+	runProperties: "w:rPr"
+};
+const PPTX_NS = {
+	paragraph: "a:p",
+	run: "a:r",
+	text: "a:t",
+	runProperties: "a:rPr"
+};
+//#endregion
+//#region src/patch/xml-patch-utils.ts
+/**
+* XML utility functions for patch operations.
+*/
+const toJson = (xmlData) => {
+	return xml2js(xmlData, {
+		captureSpacesBetweenElements: true,
+		compact: false
+	});
+};
+/**
+* Creates the inner content of a text element (`w:t` / `a:t`).
+*
+* Returns `[{ type: "text", text }]` for non-empty text, `[]` for empty.
+* The `xml:space` attribute is handled separately by `patchSpaceAttribute`.
+*/
+const createTextElementContents = (text) => text === "" ? [] : [{
+	text,
+	type: "text"
+}];
+const patchSpaceAttribute = (element) => ({
+	...element,
+	attributes: { "xml:space": "preserve" }
+});
+const getFirstLevelElements = (relationships, id) => relationships.elements?.filter((e) => e.name === id)[0].elements ?? [];
+//#endregion
+//#region src/patch/paragraph-split-inject.ts
+var TokenNotFoundError = class extends Error {
+	constructor(token) {
+		super(`Token ${token} not found`);
+		this.name = "TokenNotFoundError";
+	}
+};
+function createSplitInject(ns, createTextElementContents, options) {
+	const preserveSpace = options?.preserveSpace ?? true;
+	const findRunElementIndexWithToken = (paragraphElement, token) => {
+		for (let i = 0; i < (paragraphElement.elements ?? []).length; i++) {
+			const element = paragraphElement.elements[i];
+			if (element.type === "element" && element.name === ns.run) {
+				const textElement = (element.elements ?? []).filter((e) => e.type === "element" && e.name === ns.text);
+				for (const text of textElement) {
+					if (!text.elements?.[0]) continue;
+					if (text.elements[0].text?.includes(token)) return i;
+				}
+			}
+		}
+		throw new TokenNotFoundError(token);
+	};
+	const splitRunElement = (runElement, token) => {
+		let splitIndex = -1;
+		const splitElements = runElement.elements?.map((e, i) => {
+			if (splitIndex !== -1) return e;
+			if (e.type === "element" && e.name === ns.text) {
+				const splitText = (e.elements?.[0]?.text ?? "").split(token);
+				const newElements = splitText.map((t) => ({
+					...e,
+					...preserveSpace ? patchSpaceAttribute(e) : {},
+					elements: createTextElementContents(t)
+				}));
+				if (splitText.length > 1) splitIndex = i;
+				return newElements;
+			} else return e;
+		}).flat() ?? [];
+		return {
+			left: {
+				...JSON.parse(JSON.stringify(runElement)),
+				elements: splitElements.slice(0, splitIndex + 1)
+			},
+			right: {
+				...JSON.parse(JSON.stringify(runElement)),
+				elements: splitElements.slice(splitIndex + 1)
+			}
+		};
+	};
+	return {
+		findRunElementIndexWithToken,
+		splitRunElement
+	};
+}
+//#endregion
+//#region src/patch/paragraph-token-replacer.ts
+const ReplaceMode = {
+	START: 0,
+	MIDDLE: 1,
+	END: 2
+};
+function createTokenReplacer(createTextElementContents, options) {
+	const preserveSpace = options?.preserveSpace ?? true;
+	const patchTextElement = (element, text) => {
+		element.elements = createTextElementContents(text);
+		return element;
+	};
+	return ({ paragraphElement, renderedParagraph, originalText, replacementText }) => {
+		const startIndex = renderedParagraph.text.indexOf(originalText);
+		const endIndex = startIndex + originalText.length - 1;
+		let replaceMode = ReplaceMode.START;
+		for (const run of renderedParagraph.runs) for (const { text, index, start, end } of run.parts) switch (replaceMode) {
+			case ReplaceMode.START:
+				if (startIndex >= start && startIndex <= end) {
+					const offsetStartIndex = startIndex - start;
+					const offsetEndIndex = Math.min(endIndex, end) - start;
+					const partToReplace = text.substring(offsetStartIndex, offsetEndIndex + 1);
+					if (partToReplace === "") continue;
+					const firstPart = text.replace(partToReplace, replacementText);
+					patchTextElement(paragraphElement.elements[run.index].elements[index], firstPart);
+					replaceMode = ReplaceMode.MIDDLE;
+					continue;
+				}
+				break;
+			case ReplaceMode.MIDDLE:
+				if (endIndex <= end) {
+					const lastPart = text.substring(endIndex - start + 1);
+					patchTextElement(paragraphElement.elements[run.index].elements[index], lastPart);
+					const currentElement = paragraphElement.elements[run.index].elements[index];
+					paragraphElement.elements[run.index].elements[index] = preserveSpace ? patchSpaceAttribute(currentElement) : currentElement;
+					replaceMode = ReplaceMode.END;
+				} else patchTextElement(paragraphElement.elements[run.index].elements[index], "");
+				break;
+		}
+		return paragraphElement;
+	};
+}
+//#endregion
+//#region src/patch/run-renderer.ts
+function createRunRenderer(ns) {
+	const renderParagraphNode = (node) => {
+		if (node.element.name !== ns.paragraph) throw new Error(`Invalid node type: ${node.element.name}`);
+		if (!node.element.elements) return {
+			index: -1,
+			pathToParagraph: [],
+			runs: [],
+			text: ""
+		};
+		let currentRunStringLength = 0;
+		const runs = node.element.elements.map((element, i) => ({
+			element,
+			i
+		})).filter(({ element }) => element.name === ns.run).map(({ element, i }) => {
+			const renderedRunNode = renderRunNode(element, i, currentRunStringLength);
+			currentRunStringLength += renderedRunNode.text.length;
+			return renderedRunNode;
+		}).filter((e) => Boolean(e));
+		const text = runs.reduce((acc, curr) => acc + curr.text, "");
+		return {
+			index: node.index,
+			pathToParagraph: buildNodePath(node),
+			runs,
+			text
+		};
+	};
+	const renderRunNode = (node, index, currentRunStringIndex) => {
+		if (!node.elements) return {
+			end: currentRunStringIndex,
+			index: -1,
+			parts: [],
+			start: currentRunStringIndex,
+			text: ""
+		};
+		let currentTextStringIndex = currentRunStringIndex;
+		const parts = node.elements.map((element, i) => element.name === ns.text && element.elements && element.elements.length > 0 ? (() => {
+			const partStart = currentTextStringIndex;
+			currentTextStringIndex += (element.elements[0].text?.toString() ?? "").length;
+			return {
+				end: currentTextStringIndex - 1,
+				index: i,
+				start: partStart,
+				text: element.elements[0].text?.toString() ?? ""
+			};
+		})() : void 0).filter((e) => Boolean(e)).map((e) => e);
+		const text = parts.reduce((acc, curr) => acc + curr.text, "");
+		return {
+			end: currentTextStringIndex - 1,
+			index,
+			parts,
+			start: currentRunStringIndex,
+			text
+		};
+	};
+	return renderParagraphNode;
+}
+const buildNodePath = (node) => node.parent ? [...buildNodePath(node.parent), node.index] : [node.index];
+//#endregion
+//#region src/patch/xml-traverser.ts
+const elementsToWrapper = (wrapper) => wrapper.element.elements?.map((e, i) => ({
+	element: e,
+	index: i,
+	parent: wrapper
+})) ?? [];
+function createTraverser(ns) {
+	const renderParagraphNode = createRunRenderer(ns);
+	const traverse = (node) => {
+		let renderedParagraphs = [];
+		const queue = [...elementsToWrapper({
+			element: node,
+			index: 0,
+			parent: void 0
+		})];
+		let currentNode;
+		while (queue.length > 0) {
+			currentNode = queue.shift();
+			if (currentNode.element.name === ns.paragraph) renderedParagraphs = [...renderedParagraphs, renderParagraphNode(currentNode)];
+			queue.push(...elementsToWrapper(currentNode));
+		}
+		return renderedParagraphs;
+	};
+	const findLocationOfText = (node, text) => traverse(node).filter((p) => p.text.includes(text));
+	return {
+		traverse,
+		findLocationOfText
+	};
+}
+//#endregion
+//#region src/patch/xml-replacer.ts
+const SPLIT_TOKEN = "ɵ";
+function createReplacer(config) {
+	const { ns, formatChild } = config;
+	const { findLocationOfText } = createTraverser(ns);
+	const replaceTokenInParagraphElement = createTokenReplacer(createTextElementContents, { preserveSpace: config.preserveSpace });
+	const { findRunElementIndexWithToken, splitRunElement } = createSplitInject(ns, createTextElementContents, { preserveSpace: config.preserveSpace });
+	const replacer = ({ json, patch, patchText, context, keepOriginalStyles = true }) => {
+		const renderedParagraphs = findLocationOfText(json, patchText);
+		if (renderedParagraphs.length === 0) return {
+			didFindOccurrence: false,
+			element: json
+		};
+		for (const renderedParagraph of renderedParagraphs) {
+			const textJson = patch.children.flatMap((c) => formatChild(c, context));
+			switch (patch.type) {
+				case "file": {
+					const parentElement = goToParentElementFromPath(json, renderedParagraph.pathToParagraph);
+					const elementIndex = getLastElementIndexFromPath(renderedParagraph.pathToParagraph);
+					parentElement.elements.splice(elementIndex, 1, ...textJson);
+					break;
+				}
+				default: {
+					const paragraphElement = goToElementFromPath(json, renderedParagraph.pathToParagraph);
+					replaceTokenInParagraphElement({
+						originalText: patchText,
+						paragraphElement,
+						renderedParagraph,
+						replacementText: SPLIT_TOKEN
+					});
+					const index = findRunElementIndexWithToken(paragraphElement, SPLIT_TOKEN);
+					const runElementToBeReplaced = paragraphElement.elements[index];
+					const { left, right } = splitRunElement(runElementToBeReplaced, SPLIT_TOKEN);
+					let newRunElements = textJson;
+					let patchedRightElement = right;
+					if (keepOriginalStyles) {
+						const runElementNonTextualElements = runElementToBeReplaced.elements.filter((e) => e.type === "element" && e.name === ns.runProperties);
+						newRunElements = textJson.map((e) => {
+							if (e.type !== "element" || e.name !== ns.run || e.elements?.some((c) => c.type === "element" && c.name === ns.runProperties)) return e;
+							return {
+								...e,
+								elements: [...runElementNonTextualElements, ...e.elements ?? []]
+							};
+						});
+						patchedRightElement = {
+							...right,
+							elements: [...runElementNonTextualElements, ...right.elements]
+						};
+					}
+					paragraphElement.elements.splice(index, 1, left, ...newRunElements, patchedRightElement);
+					break;
+				}
+			}
+		}
+		return {
+			didFindOccurrence: true,
+			element: json
+		};
+	};
+	return replacer;
+}
+const goToElementFromPath = (json, path) => {
+	let element = json;
+	for (let i = 1; i < path.length; i++) {
+		const index = path[i];
+		element = element.elements[index];
+	}
+	return element;
+};
+const goToParentElementFromPath = (json, path) => goToElementFromPath(json, path.slice(0, -1));
+const getLastElementIndexFromPath = (path) => path[path.length - 1];
+//#endregion
+//#region src/patch/content-types-manager.ts
+const appendContentType = (element, contentType, extension) => {
+	const relationshipElements = getFirstLevelElements(element, "Types");
+	if (relationshipElements.some((el) => el.type === "element" && el.name === "Default" && el?.attributes?.ContentType === contentType && el?.attributes?.Extension === extension)) return;
+	relationshipElements.push({
+		attributes: {
+			ContentType: contentType,
+			Extension: extension
+		},
+		name: "Default",
+		type: "element"
+	});
+};
+//#endregion
+//#region src/patch/relationship-manager.ts
+const getIdFromRelationshipId = (relationshipId) => {
+	const output = parseInt(relationshipId.substring(3), 10);
+	return isNaN(output) ? 0 : output;
+};
+const getNextRelationshipIndex = (relationships) => {
+	return getFirstLevelElements(relationships, "Relationships").map((e) => getIdFromRelationshipId(e.attributes?.Id?.toString() ?? "")).reduce((acc, curr) => Math.max(acc, curr), 0) + 1;
+};
+const appendRelationship = (relationships, id, type, target, targetMode) => {
+	const relationshipElements = getFirstLevelElements(relationships, "Relationships");
+	relationshipElements.push({
+		attributes: {
+			Id: `rId${id}`,
+			Target: target,
+			TargetMode: targetMode,
+			Type: type
+		},
+		name: "Relationship",
+		type: "element"
+	});
+	return relationshipElements;
+};
+//#endregion
+export { createTraverser as a, TokenNotFoundError as c, getFirstLevelElements as d, patchSpaceAttribute as f, PPTX_NS as h, createReplacer as i, createSplitInject as l, DOCX_NS as m, getNextRelationshipIndex as n, createRunRenderer as o, toJson as p, appendContentType as r, createTokenReplacer as s, appendRelationship as t, createTextElementContents as u };

package/dist/smartart/index.d.mts

@@ -1,2 +1,2 @@
-import { a as Point, c as Connection, d as getLayoutXml, f as getStyleXml, h as STYLE_CATEGORIES, i as SmartArtData, l as DEFAULT_DRAWING_XML, m as LAYOUT_CATEGORIES, n as createDataModel, o as TransPoint, p as COLOR_CATEGORIES, r as SmartArtCollection, s as DataModel, t as TreeNode, u as getColorXml } from "../index-DigYTiB_.mjs";
+import { a as Point, c as Connection, d as getLayoutXml, f as getStyleXml, h as STYLE_CATEGORIES, i as SmartArtData, l as DEFAULT_DRAWING_XML, m as LAYOUT_CATEGORIES, n as createDataModel, o as TransPoint, p as COLOR_CATEGORIES, r as SmartArtCollection, s as DataModel, t as TreeNode, u as getColorXml } from "../index-CZxcE4Q6.mjs";
 export { COLOR_CATEGORIES, Connection, DEFAULT_DRAWING_XML, DataModel, LAYOUT_CATEGORIES, Point, STYLE_CATEGORIES, SmartArtCollection, SmartArtData, TransPoint, TreeNode, createDataModel, getColorXml, getLayoutXml, getStyleXml };

package/dist/values.d.mts

@@ -1,2 +1,2 @@
-import { C as uCharHexNumber, S as twipsMeasureValue, T as unsignedDecimalNumber, _ as pointMeasureValue, a as ThemeColor, b as signedHpsMeasureValue, c as dateTimeValue, d as hexBinary, f as hexColorValue, g as percentageValue, h as measurementOrPercentValue, i as RelativeMeasure, l as decimalNumber, m as longHexNumber, n as PositivePercentage, o as ThemeFont, p as hpsMeasureValue, r as PositiveUniversalMeasure, s as UniversalMeasure, t as Percentage, u as eighthPointMeasureValue, v as positiveUniversalMeasureValue, w as universalMeasureValue, x as signedTwipsMeasureValue, y as shortHexNumber } from "./values-CIh0bdS1.mjs";
+import { C as uCharHexNumber, S as twipsMeasureValue, T as unsignedDecimalNumber, _ as pointMeasureValue, a as ThemeColor, b as signedHpsMeasureValue, c as dateTimeValue, d as hexBinary, f as hexColorValue, g as percentageValue, h as measurementOrPercentValue, i as RelativeMeasure, l as decimalNumber, m as longHexNumber, n as PositivePercentage, o as ThemeFont, p as hpsMeasureValue, r as PositiveUniversalMeasure, s as UniversalMeasure, t as Percentage, u as eighthPointMeasureValue, v as positiveUniversalMeasureValue, w as universalMeasureValue, x as signedTwipsMeasureValue, y as shortHexNumber } from "./values-QyWq4U4A.mjs";
 export { Percentage, PositivePercentage, PositiveUniversalMeasure, RelativeMeasure, ThemeColor, ThemeFont, UniversalMeasure, dateTimeValue, decimalNumber, eighthPointMeasureValue, hexBinary, hexColorValue, hpsMeasureValue, longHexNumber, measurementOrPercentValue, percentageValue, pointMeasureValue, positiveUniversalMeasureValue, shortHexNumber, signedHpsMeasureValue, signedTwipsMeasureValue, twipsMeasureValue, uCharHexNumber, universalMeasureValue, unsignedDecimalNumber };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@office-open/core",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Shared OOXML infrastructure: XmlComponent, value validators, unit converters",
   "keywords": [
     "core",
@@ -49,17 +49,13 @@
     "./drawingml": {
       "types": "./dist/drawingml/index.d.mts",
       "import": "./dist/drawingml/index.mjs"
-    },
-    "./archive": {
-      "types": "./dist/archive.d.mts",
-      "import": "./dist/archive.mjs"
     }
   },
   "dependencies": {
     "fflate": "0.8.3",
     "hash.js": "1.1.7",
     "nanoid": "5.1.11",
-    "@office-open/xml": "0.6.4"
+    "@office-open/xml": "0.6.5"
   },
   "scripts": {
     "dev": "basis build --stub",

package/dist/archive.d.mts

@@ -1,58 +0,0 @@
-import { Element } from "@office-open/xml";
-
-//#region src/archive.d.ts
-/**
- * Unzip an OOXML file (.docx, .pptx) into a Map of path → Uint8Array.
- */
-declare function unzipToMap(data: Uint8Array): Map<string, Uint8Array>;
-/**
- * Read a file from the zip as a UTF-8 string.
- */
-declare function readTextFromZip(zip: Map<string, Uint8Array>, path: string): string | undefined;
-/**
- * Parse an XML file from the zip into an Element tree.
- */
-declare function readXmlFromZip(zip: Map<string, Uint8Array>, path: string): Element | undefined;
-/**
- * Read a binary file from the zip.
- */
-declare function readBinaryFromZip(zip: Map<string, Uint8Array>, path: string): Uint8Array | undefined;
-/**
- * Parse all XML files in the zip into Element trees.
- * Skips media files, binary files, and the main document/presentation file.
- */
-declare function readAllXmlParts(zip: Map<string, Uint8Array>, options?: {
-  skipPaths?: string[];
-}): Record<string, Element>;
-/**
- * List all files in the zip matching a prefix.
- */
-declare function listFiles(zip: Map<string, Uint8Array>, prefix: string): string[];
-/**
- * Convert Uint8Array to base64 string.
- */
-declare function uint8ToBase64(data: Uint8Array): string;
-/**
- * Determine image type from file extension.
- */
-declare function getImageType(fileName: string): string;
-interface Relationship {
-  id: string;
-  target: string;
-  type: string;
-  targetMode?: string;
-}
-declare function parseRels(zip: Map<string, Uint8Array>, path: string): Relationship[];
-declare function findRel(rels: Relationship[], id: string): Relationship | undefined;
-declare function findRelsByType(rels: Relationship[], typeSubstring: string): Relationship[];
-/**
- * Zip a map of path → Uint8Array/string into a ZIP buffer.
- * XML strings are auto-encoded to UTF-8 bytes.
- */
-declare function zipToBuffer(files: Map<string, Uint8Array | string>): Uint8Array;
-/**
- * Serialize an Element tree to an XML string.
- */
-declare function elementToXml(el: Element): string;
-//#endregion
-export { Relationship, elementToXml, findRel, findRelsByType, getImageType, listFiles, parseRels, readAllXmlParts, readBinaryFromZip, readTextFromZip, readXmlFromZip, uint8ToBase64, unzipToMap, zipToBuffer };

package/dist/archive.mjs

@@ -1,135 +0,0 @@
-import { attr, js2xml, xml2js } from "@office-open/xml";
-import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
-//#region src/archive.ts
-const XML_PARSE_OPTIONS = {
-	nativeTypeAttributes: true,
-	captureSpacesBetweenElements: true
-};
-/**
-* Unzip an OOXML file (.docx, .pptx) into a Map of path → Uint8Array.
-*/
-function unzipToMap(data) {
-	const entries = unzipSync(data);
-	const map = /* @__PURE__ */ new Map();
-	for (const [path, bytes] of Object.entries(entries)) map.set(path, bytes);
-	return map;
-}
-/**
-* Read a file from the zip as a UTF-8 string.
-*/
-function readTextFromZip(zip, path) {
-	const data = zip.get(path);
-	if (data === void 0) return void 0;
-	return strFromU8(data);
-}
-/**
-* Parse an XML file from the zip into an Element tree.
-*/
-function readXmlFromZip(zip, path) {
-	const text = readTextFromZip(zip, path);
-	if (text === void 0) return void 0;
-	return xml2js(text, XML_PARSE_OPTIONS).elements?.find((e) => e.type === "element");
-}
-/**
-* Read a binary file from the zip.
-*/
-function readBinaryFromZip(zip, path) {
-	return zip.get(path);
-}
-/**
-* Parse all XML files in the zip into Element trees.
-* Skips media files, binary files, and the main document/presentation file.
-*/
-function readAllXmlParts(zip, options) {
-	const parts = {};
-	const skip = new Set(options?.skipPaths ?? []);
-	for (const path of zip.keys()) {
-		if (skip.has(path)) continue;
-		if (path.startsWith("word/media/") || path.startsWith("ppt/media/") || path.startsWith("xl/media/") || path.endsWith(".png") || path.endsWith(".jpg") || path.endsWith(".jpeg") || path.endsWith(".gif") || path.endsWith(".bmp") || path.endsWith(".tif") || path.endsWith(".tiff") || path.endsWith(".emf") || path.endsWith(".wmf") || path.endsWith(".svg") || path.endsWith(".wav") || path.endsWith(".mp3") || path.endsWith(".mp4") || path.endsWith(".avi") || path.endsWith(".wmv") || path.endsWith(".thmx") || path.endsWith(".bin")) continue;
-		const el = readXmlFromZip(zip, path);
-		if (el) parts[path] = el;
-	}
-	return parts;
-}
-/**
-* List all files in the zip matching a prefix.
-*/
-function listFiles(zip, prefix) {
-	const result = [];
-	for (const path of zip.keys()) if (path.startsWith(prefix)) result.push(path);
-	return result;
-}
-/**
-* Convert Uint8Array to base64 string.
-*/
-function uint8ToBase64(data) {
-	const chunkSize = 8192;
-	let binary = "";
-	for (let i = 0; i < data.length; i += chunkSize) {
-		const chunk = data.subarray(i, Math.min(i + chunkSize, data.length));
-		binary += String.fromCharCode(...chunk);
-	}
-	return btoa(binary);
-}
-/**
-* Determine image type from file extension.
-*/
-function getImageType(fileName) {
-	const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
-	if ([
-		"png",
-		"jpg",
-		"jpeg",
-		"gif",
-		"bmp",
-		"tif",
-		"tiff",
-		"ico",
-		"emf",
-		"wmf",
-		"svg"
-	].includes(ext)) return ext === "jpeg" ? "jpg" : ext;
-	return "png";
-}
-function parseRels(zip, path) {
-	const xml = readXmlFromZip(zip, path);
-	if (!xml) return [];
-	const result = [];
-	for (const rel of xml.elements ?? []) {
-		if (rel.name !== "Relationship") continue;
-		const id = attr(rel, "Id");
-		const target = attr(rel, "Target");
-		const type = attr(rel, "Type");
-		const targetMode = attr(rel, "TargetMode");
-		if (id && target) result.push({
-			id,
-			target,
-			type: type ?? "",
-			...targetMode ? { targetMode } : {}
-		});
-	}
-	return result;
-}
-function findRel(rels, id) {
-	return rels.find((r) => r.id === id);
-}
-function findRelsByType(rels, typeSubstring) {
-	return rels.filter((r) => r.type.includes(typeSubstring));
-}
-/**
-* Zip a map of path → Uint8Array/string into a ZIP buffer.
-* XML strings are auto-encoded to UTF-8 bytes.
-*/
-function zipToBuffer(files) {
-	const entries = {};
-	for (const [path, data] of files) entries[path] = typeof data === "string" ? strToU8(data) : data;
-	return zipSync(entries);
-}
-/**
-* Serialize an Element tree to an XML string.
-*/
-function elementToXml(el) {
-	return js2xml(el);
-}
-//#endregion
-export { elementToXml, findRel, findRelsByType, getImageType, listFiles, parseRels, readAllXmlParts, readBinaryFromZip, readTextFromZip, readXmlFromZip, uint8ToBase64, unzipToMap, zipToBuffer };