ooxml.js 2.4.1 → 2.5.0

package/dist/compact.js

@@ -0,0 +1,152 @@
+import { PackageSchema } from "./model/package.js";
+import { decodePackage, encodePackage } from "./codec.js";
+import { z } from "zod";
+//#region src/compact.ts
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function isCompactAttrPairs(value) {
+	return isUnknownArray(value) && value.every((v) => typeof v === "number");
+}
+function isCompactXmlNode(value) {
+	if (!isUnknownArray(value)) return false;
+	const code = value[0];
+	if (code === 1 || code === 2 || code === 3) return value.length === 2 && typeof value[1] === "number";
+	if (code === 4) return value.length === 2 && isCompactAttrPairs(value[1]);
+	if (code === 5) return value.length === 3 && typeof value[1] === "number" && typeof value[2] === "number";
+	if (code === 0) return value.length === 4 && typeof value[1] === "number" && isCompactAttrPairs(value[2]) && Array.isArray(value[3]) && value[3].every(isCompactXmlNode);
+	return false;
+}
+const CompactXmlNodeSchema = z.custom(isCompactXmlNode);
+const CompactPartSchema = z.union([z.array(CompactXmlNodeSchema), z.number()]);
+const CompactPackageSchema = z.object({
+	s: z.array(z.string()),
+	p: z.record(z.string(), CompactPartSchema)
+});
+var StringTable = class {
+	indices = /* @__PURE__ */ new Map();
+	strings = [];
+	intern(value) {
+		const existing = this.indices.get(value);
+		if (existing !== void 0) return existing;
+		const index = this.strings.length;
+		this.indices.set(value, index);
+		this.strings.push(value);
+		return index;
+	}
+};
+function encodeAttrs(attributes, table) {
+	const pairs = [];
+	for (const attribute of attributes) pairs.push(table.intern(attribute.name), table.intern(attribute.value));
+	return pairs;
+}
+function encodeNode(node, table) {
+	switch (node.type) {
+		case "text": return [1, table.intern(node.value)];
+		case "cdata": return [2, table.intern(node.value)];
+		case "comment": return [3, table.intern(node.value)];
+		case "declaration": return [4, encodeAttrs(node.attributes, table)];
+		case "pi": return [
+			5,
+			table.intern(node.target),
+			table.intern(node.content)
+		];
+		case "element": return [
+			0,
+			table.intern(node.tag),
+			encodeAttrs(node.attributes, table),
+			node.children.map((child) => encodeNode(child, table))
+		];
+	}
+}
+function packageToCompact(pkg) {
+	const table = new StringTable();
+	const p = {};
+	for (const [path, part] of Object.entries(pkg.parts)) p[path] = part.kind === "binary" ? table.intern(part.base64) : part.nodes.map((node) => encodeNode(node, table));
+	return {
+		s: table.strings,
+		p
+	};
+}
+function stringAt(strings, index) {
+	const value = strings[index];
+	if (value === void 0) throw new Error(`fromCompact: string table index ${index} is out of range`);
+	return value;
+}
+function decodeAttrs(pairs, strings) {
+	const attributes = [];
+	for (let i = 0; i < pairs.length; i += 2) {
+		const nameIdx = pairs[i];
+		const valueIdx = pairs[i + 1];
+		if (nameIdx === void 0 || valueIdx === void 0) throw new Error("fromCompact: attribute index pairs array has odd length");
+		attributes.push({
+			name: stringAt(strings, nameIdx),
+			value: stringAt(strings, valueIdx)
+		});
+	}
+	return attributes;
+}
+function decodeNode(node, strings) {
+	switch (node[0]) {
+		case 1: return {
+			type: "text",
+			value: stringAt(strings, node[1])
+		};
+		case 2: return {
+			type: "cdata",
+			value: stringAt(strings, node[1])
+		};
+		case 3: return {
+			type: "comment",
+			value: stringAt(strings, node[1])
+		};
+		case 4: return {
+			type: "declaration",
+			attributes: decodeAttrs(node[1], strings)
+		};
+		case 5: return {
+			type: "pi",
+			target: stringAt(strings, node[1]),
+			content: stringAt(strings, node[2])
+		};
+		case 0: return {
+			type: "element",
+			tag: stringAt(strings, node[1]),
+			attributes: decodeAttrs(node[2], strings),
+			children: node[3].map((child) => decodeNode(child, strings))
+		};
+	}
+}
+function compactToPackage(cpkg) {
+	const parts = {};
+	for (const [path, part] of Object.entries(cpkg.p)) parts[path] = typeof part === "number" ? {
+		kind: "binary",
+		base64: stringAt(cpkg.s, part)
+	} : {
+		kind: "xml",
+		nodes: part.map((node) => decodeNode(node, cpkg.s))
+	};
+	return { parts };
+}
+const compactCodec = z.codec(PackageSchema, CompactPackageSchema, {
+	decode: (pkg) => packageToCompact(pkg),
+	encode: (cpkg) => compactToPackage(cpkg)
+});
+function toCompact(pkg) {
+	return z.decode(compactCodec, pkg);
+}
+function fromCompact(cpkg) {
+	return z.encode(compactCodec, cpkg);
+}
+const compactPackageCodec = z.codec(z.instanceof(Uint8Array), CompactPackageSchema, {
+	decode: (bytes) => toCompact(decodePackage(bytes)),
+	encode: (cpkg) => encodePackage(fromCompact(cpkg))
+});
+function decodeCompactPackage(bytes) {
+	return z.decode(compactPackageCodec, bytes);
+}
+function encodeCompactPackage(cpkg) {
+	return z.encode(compactPackageCodec, cpkg);
+}
+//#endregion
+export { CompactPackageSchema, CompactPartSchema, CompactXmlNodeSchema, compactCodec, compactPackageCodec, decodeCompactPackage, encodeCompactPackage, fromCompact, isCompactXmlNode, toCompact };

package/dist/image/sniff.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/image/sniff.ts
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const JPEG_SIGNATURE = [
+	255,
+	216,
+	255
+];
+function startsWith(bytes, signature) {
+	if (bytes.length < signature.length) return false;
+	for (let i = 0; i < signature.length; i++) if (bytes[i] !== signature[i]) return false;
+	return true;
+}
+function sniffImageFormat(bytes) {
+	if (startsWith(bytes, PNG_SIGNATURE)) return "png";
+	if (startsWith(bytes, JPEG_SIGNATURE)) return "jpeg";
+}
+//#endregion
+exports.sniffImageFormat = sniffImageFormat;

package/dist/image/sniff.d.cts

@@ -0,0 +1,5 @@
+//#region src/image/sniff.d.ts
+type ImageFormat = 'png' | 'jpeg';
+declare function sniffImageFormat(bytes: Uint8Array<ArrayBuffer>): ImageFormat | undefined;
+//#endregion
+export { ImageFormat, sniffImageFormat };

package/dist/image/sniff.d.ts

@@ -0,0 +1,5 @@
+//#region src/image/sniff.d.ts
+type ImageFormat = 'png' | 'jpeg';
+declare function sniffImageFormat(bytes: Uint8Array<ArrayBuffer>): ImageFormat | undefined;
+//#endregion
+export { ImageFormat, sniffImageFormat };

package/dist/image/sniff.js

@@ -0,0 +1,27 @@
+//#region src/image/sniff.ts
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const JPEG_SIGNATURE = [
+	255,
+	216,
+	255
+];
+function startsWith(bytes, signature) {
+	if (bytes.length < signature.length) return false;
+	for (let i = 0; i < signature.length; i++) if (bytes[i] !== signature[i]) return false;
+	return true;
+}
+function sniffImageFormat(bytes) {
+	if (startsWith(bytes, PNG_SIGNATURE)) return "png";
+	if (startsWith(bytes, JPEG_SIGNATURE)) return "jpeg";
+}
+//#endregion
+export { sniffImageFormat };