@8ms/helpers 3.2.6 → 3.2.8

package/dist/stream/server/json/logic.mjs

@@ -0,0 +1,16 @@
+import { Readable, Transform } from "stream";
+//#region src/stream/server/json/logic.ts
+const toRowReadable = (source) => {
+	return source instanceof Readable ? source : Readable.from(source, { objectMode: true });
+};
+/**
+* Applies the optional per-row callback, dropping rows for which it resolves null/undefined.
+*/
+const rowCallbackTransform = (rowCallback) => new Transform({
+	objectMode: true,
+	transform(row, _encoding, callback) {
+		Promise.resolve(rowCallback(row)).then((result) => callback(null, null === result || void 0 === result ? void 0 : result)).catch((error) => callback(error));
+	}
+});
+//#endregion
+export { rowCallbackTransform, toRowReadable };

package/dist/stream/server/json/read.cjs

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_stream_server_sort = require("../sort.cjs");
+const require_stream_server_json_logic = require("./logic.cjs");
+let stream = require("stream");
+let zlib = require("zlib");
+zlib = require_runtime.__toESM(zlib);
+let stream_promises = require("stream/promises");
+//#region src/stream/server/json/read.ts
+const unwrapStreamArrayValue = () => new stream.Transform({
+	objectMode: true,
+	transform({ value }, _encoding, callback) {
+		callback(null, value);
+	}
+});
+const collectJsonArray = async (source, rowCallback, sortCallback) => {
+	const { streamArray } = await import("stream-json/streamers/stream-array.js");
+	const rows = [];
+	const steps = [
+		source,
+		streamArray.withParserAsStream(),
+		unwrapStreamArrayValue()
+	];
+	if (rowCallback) steps.push(require_stream_server_json_logic.rowCallbackTransform(rowCallback));
+	if (sortCallback) steps.push(require_stream_server_sort.sort(sortCallback));
+	steps.push(new stream.Transform({
+		objectMode: true,
+		transform(row, _encoding, callback) {
+			rows.push(row);
+			callback();
+		}
+	}));
+	await (0, stream_promises.pipeline)(steps);
+	return rows;
+};
+/** Parses a JSON array source incrementally, row by row, without buffering the whole document first. */
+const readJsonStream = async (props) => {
+	return collectJsonArray(props.source, props.rowCallback, props.sortCallback);
+};
+/** Same as readJsonStream, but gunzips `source` before parsing it as a JSON array. */
+const readJsonGzipStream = async (props) => {
+	return collectJsonArray(props.source.pipe(zlib.default.createGunzip()), props.rowCallback, props.sortCallback);
+};
+//#endregion
+exports.readJsonGzipStream = readJsonGzipStream;
+exports.readJsonStream = readJsonStream;

package/dist/stream/server/json/read.d.cts

@@ -0,0 +1,7 @@
+import { ReadJsonStreamProps } from "./logic.cjs";
+//#region src/stream/server/json/read.d.ts
+/** Parses a JSON array source incrementally, row by row, without buffering the whole document first. */
+export declare const readJsonStream: <T = any>(props: ReadJsonStreamProps<T>) => Promise<T[]>;
+/** Same as readJsonStream, but gunzips `source` before parsing it as a JSON array. */
+export declare const readJsonGzipStream: <T = any>(props: ReadJsonStreamProps<T>) => Promise<T[]>;
+//#endregion

package/dist/stream/server/json/read.d.mts

@@ -0,0 +1,7 @@
+import { ReadJsonStreamProps } from "./logic.mjs";
+//#region src/stream/server/json/read.d.ts
+/** Parses a JSON array source incrementally, row by row, without buffering the whole document first. */
+export declare const readJsonStream: <T = any>(props: ReadJsonStreamProps<T>) => Promise<T[]>;
+/** Same as readJsonStream, but gunzips `source` before parsing it as a JSON array. */
+export declare const readJsonGzipStream: <T = any>(props: ReadJsonStreamProps<T>) => Promise<T[]>;
+//#endregion

package/dist/stream/server/json/read.mjs

@@ -0,0 +1,42 @@
+import { sort } from "../sort.mjs";
+import { rowCallbackTransform } from "./logic.mjs";
+import { Transform } from "stream";
+import zlib from "zlib";
+import { pipeline } from "stream/promises";
+//#region src/stream/server/json/read.ts
+const unwrapStreamArrayValue = () => new Transform({
+	objectMode: true,
+	transform({ value }, _encoding, callback) {
+		callback(null, value);
+	}
+});
+const collectJsonArray = async (source, rowCallback, sortCallback) => {
+	const { streamArray } = await import("stream-json/streamers/stream-array.js");
+	const rows = [];
+	const steps = [
+		source,
+		streamArray.withParserAsStream(),
+		unwrapStreamArrayValue()
+	];
+	if (rowCallback) steps.push(rowCallbackTransform(rowCallback));
+	if (sortCallback) steps.push(sort(sortCallback));
+	steps.push(new Transform({
+		objectMode: true,
+		transform(row, _encoding, callback) {
+			rows.push(row);
+			callback();
+		}
+	}));
+	await pipeline(steps);
+	return rows;
+};
+/** Parses a JSON array source incrementally, row by row, without buffering the whole document first. */
+const readJsonStream = async (props) => {
+	return collectJsonArray(props.source, props.rowCallback, props.sortCallback);
+};
+/** Same as readJsonStream, but gunzips `source` before parsing it as a JSON array. */
+const readJsonGzipStream = async (props) => {
+	return collectJsonArray(props.source.pipe(zlib.createGunzip()), props.rowCallback, props.sortCallback);
+};
+//#endregion
+export { readJsonGzipStream, readJsonStream };

package/dist/stream/server/json/write.cjs

@@ -0,0 +1,69 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_stream_server_sort = require("../sort.cjs");
+const require_stream_server_json_logic = require("./logic.cjs");
+let stream = require("stream");
+let zlib = require("zlib");
+zlib = require_runtime.__toESM(zlib);
+let stream_promises = require("stream/promises");
+//#region src/stream/server/json/write.ts
+/**
+* Serialises a stream of row objects into a single JSON array without ever holding
+* the full collection in memory - one stringified row at a time.
+*/
+var JsonArrayStringifier = class extends stream.Transform {
+	isFirstRow = true;
+	constructor() {
+		super({
+			writableObjectMode: true,
+			readableObjectMode: false
+		});
+	}
+	_transform(row, _encoding, callback) {
+		this.push((this.isFirstRow ? "[" : ",") + JSON.stringify(row));
+		this.isFirstRow = false;
+		callback();
+	}
+	_flush(callback) {
+		this.push(this.isFirstRow ? "[]" : "]");
+		callback();
+	}
+};
+/** Serialises a stream of row objects into newline-delimited JSON, one stringified row at a time. */
+var JsonNewLineStringifier = class extends stream.Transform {
+	constructor() {
+		super({
+			writableObjectMode: true,
+			readableObjectMode: false
+		});
+	}
+	_transform(row, _encoding, callback) {
+		this.push(JSON.stringify(row) + "\n");
+		callback();
+	}
+};
+const jsonNewLineStringifier = () => new JsonNewLineStringifier();
+const buildWriteSteps = ({ source, rowCallback, sortCallback }) => {
+	const steps = [require_stream_server_json_logic.toRowReadable(source)];
+	if (rowCallback) steps.push(require_stream_server_json_logic.rowCallbackTransform(rowCallback));
+	if (sortCallback) steps.push(require_stream_server_sort.sort(sortCallback));
+	steps.push(new JsonArrayStringifier());
+	return steps;
+};
+/** Streams a row source into a single JSON array on `destination`, never buffering the full collection in memory. */
+const writeJsonStream = async (props) => {
+	await (0, stream_promises.pipeline)([...buildWriteSteps(props), props.destination]);
+};
+/** Same as writeJsonStream, but gzip-compresses the JSON array before it reaches `destination`. */
+const writeJsonGzipStream = async (props) => {
+	await (0, stream_promises.pipeline)([
+		...buildWriteSteps(props),
+		zlib.default.createGzip(),
+		props.destination
+	]);
+};
+//#endregion
+exports.JsonNewLineStringifier = JsonNewLineStringifier;
+exports.jsonNewLineStringifier = jsonNewLineStringifier;
+exports.writeJsonGzipStream = writeJsonGzipStream;
+exports.writeJsonStream = writeJsonStream;

package/dist/stream/server/json/write.d.cts

@@ -0,0 +1,14 @@
+import { WriteJsonStreamProps } from "./logic.cjs";
+import { Transform } from "stream";
+//#region src/stream/server/json/write.d.ts
+/** Serialises a stream of row objects into newline-delimited JSON, one stringified row at a time. */
+export declare class JsonNewLineStringifier extends Transform {
+  constructor();
+  _transform(row: any, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+}
+export declare const jsonNewLineStringifier: () => JsonNewLineStringifier;
+/** Streams a row source into a single JSON array on `destination`, never buffering the full collection in memory. */
+export declare const writeJsonStream: <T = any>(props: WriteJsonStreamProps<T>) => Promise<void>;
+/** Same as writeJsonStream, but gzip-compresses the JSON array before it reaches `destination`. */
+export declare const writeJsonGzipStream: <T = any>(props: WriteJsonStreamProps<T>) => Promise<void>;
+//#endregion

package/dist/stream/server/json/write.d.mts

@@ -0,0 +1,14 @@
+import { WriteJsonStreamProps } from "./logic.mjs";
+import { Transform } from "stream";
+//#region src/stream/server/json/write.d.ts
+/** Serialises a stream of row objects into newline-delimited JSON, one stringified row at a time. */
+export declare class JsonNewLineStringifier extends Transform {
+  constructor();
+  _transform(row: any, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+}
+export declare const jsonNewLineStringifier: () => JsonNewLineStringifier;
+/** Streams a row source into a single JSON array on `destination`, never buffering the full collection in memory. */
+export declare const writeJsonStream: <T = any>(props: WriteJsonStreamProps<T>) => Promise<void>;
+/** Same as writeJsonStream, but gzip-compresses the JSON array before it reaches `destination`. */
+export declare const writeJsonGzipStream: <T = any>(props: WriteJsonStreamProps<T>) => Promise<void>;
+//#endregion

package/dist/stream/server/json/write.mjs

@@ -0,0 +1,63 @@
+import { sort } from "../sort.mjs";
+import { rowCallbackTransform, toRowReadable } from "./logic.mjs";
+import { Transform } from "stream";
+import zlib from "zlib";
+import { pipeline } from "stream/promises";
+//#region src/stream/server/json/write.ts
+/**
+* Serialises a stream of row objects into a single JSON array without ever holding
+* the full collection in memory - one stringified row at a time.
+*/
+var JsonArrayStringifier = class extends Transform {
+	isFirstRow = true;
+	constructor() {
+		super({
+			writableObjectMode: true,
+			readableObjectMode: false
+		});
+	}
+	_transform(row, _encoding, callback) {
+		this.push((this.isFirstRow ? "[" : ",") + JSON.stringify(row));
+		this.isFirstRow = false;
+		callback();
+	}
+	_flush(callback) {
+		this.push(this.isFirstRow ? "[]" : "]");
+		callback();
+	}
+};
+/** Serialises a stream of row objects into newline-delimited JSON, one stringified row at a time. */
+var JsonNewLineStringifier = class extends Transform {
+	constructor() {
+		super({
+			writableObjectMode: true,
+			readableObjectMode: false
+		});
+	}
+	_transform(row, _encoding, callback) {
+		this.push(JSON.stringify(row) + "\n");
+		callback();
+	}
+};
+const jsonNewLineStringifier = () => new JsonNewLineStringifier();
+const buildWriteSteps = ({ source, rowCallback, sortCallback }) => {
+	const steps = [toRowReadable(source)];
+	if (rowCallback) steps.push(rowCallbackTransform(rowCallback));
+	if (sortCallback) steps.push(sort(sortCallback));
+	steps.push(new JsonArrayStringifier());
+	return steps;
+};
+/** Streams a row source into a single JSON array on `destination`, never buffering the full collection in memory. */
+const writeJsonStream = async (props) => {
+	await pipeline([...buildWriteSteps(props), props.destination]);
+};
+/** Same as writeJsonStream, but gzip-compresses the JSON array before it reaches `destination`. */
+const writeJsonGzipStream = async (props) => {
+	await pipeline([
+		...buildWriteSteps(props),
+		zlib.createGzip(),
+		props.destination
+	]);
+};
+//#endregion
+export { JsonNewLineStringifier, jsonNewLineStringifier, writeJsonGzipStream, writeJsonStream };

package/dist/stream/server/sort.cjs

@@ -1,41 +1,30 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let node_stream = require("node:stream");
 //#region src/stream/server/sort.ts
-const batch = 15e3;
+/**
+* Buffers every row that passes through, then emits them all sorted by `comp` once the source ends.
+* Sorting requires seeing the whole collection first, so this is a full in-memory buffer - not a
+* bounded or windowed sort - and should only be used where the full stream fits comfortably in memory.
+*/
 var SortStreamer = class extends node_stream.Transform {
-	a;
-	i;
-	k;
-	currentSize;
-	sortedArray;
+	rows = [];
 	comp;
 	constructor(options, comp) {
 		super(options);
-		this.a = new Array(batch);
-		this.i = 0;
-		this.k = 0;
-		this.currentSize = batch;
-		this.sortedArray = void 0;
 		this.comp = comp;
 	}
-	_transform(data, _, callback) {
-		if (data) {
-			this.a[this.i++] = data;
-			if (this.i === this.currentSize) {
-				this.currentSize *= 2;
-				const tmp = new Array(this.currentSize);
-				for (let j = 0; j < this.i; j++) tmp[j] = this.a[j];
-				this.a = tmp;
-			}
-		}
+	/** Collects each row as it arrives; nothing is emitted downstream yet. */
+	_transform(data, _encoding, callback) {
+		this.rows.push(data);
 		callback();
 	}
+	/** The source has ended - sort everything collected so far, then emit it all in order. */
 	_flush(callback) {
-		this.sortedArray = this.a.slice(0, this.i).sort(this.comp);
-		while (this.k < this.i) this.push(this.sortedArray[this.k++]);
+		this.rows.sort(this.comp).forEach((row) => this.push(row));
 		callback();
 	}
 };
+/** Creates a sorting Transform: buffers every row, sorts by `comp`, and emits the result once the source ends. */
 const sort = (comp, options) => {
 	return new SortStreamer(options ?? { objectMode: true }, comp);
 };

package/dist/stream/server/sort.d.cts

@@ -1,15 +1,19 @@
 import { Transform, TransformCallback, TransformOptions } from "node:stream";
 //#region src/stream/server/sort.d.ts
+/**
+ * Buffers every row that passes through, then emits them all sorted by `comp` once the source ends.
+ * Sorting requires seeing the whole collection first, so this is a full in-memory buffer - not a
+ * bounded or windowed sort - and should only be used where the full stream fits comfortably in memory.
+ */
 declare class SortStreamer<T> extends Transform {
-  private a;
-  private i;
-  private k;
-  private currentSize;
-  private sortedArray;
+  private readonly rows;
   private readonly comp;
   constructor(options: TransformOptions, comp: (a: T, b: T) => number);
-  _transform(data: T, _: BufferEncoding, callback: TransformCallback): void;
+  /** Collects each row as it arrives; nothing is emitted downstream yet. */
+  _transform(data: T, _encoding: BufferEncoding, callback: TransformCallback): void;
+  /** The source has ended - sort everything collected so far, then emit it all in order. */
   _flush(callback: TransformCallback): void;
 }
+/** Creates a sorting Transform: buffers every row, sorts by `comp`, and emits the result once the source ends. */
 export declare const sort: <T>(comp: (a: T, b: T) => number, options?: TransformOptions) => SortStreamer<T>;
 //#endregion

package/dist/stream/server/sort.d.mts

@@ -1,15 +1,19 @@
 import { Transform, TransformCallback, TransformOptions } from "node:stream";
 //#region src/stream/server/sort.d.ts
+/**
+ * Buffers every row that passes through, then emits them all sorted by `comp` once the source ends.
+ * Sorting requires seeing the whole collection first, so this is a full in-memory buffer - not a
+ * bounded or windowed sort - and should only be used where the full stream fits comfortably in memory.
+ */
 declare class SortStreamer<T> extends Transform {
-  private a;
-  private i;
-  private k;
-  private currentSize;
-  private sortedArray;
+  private readonly rows;
   private readonly comp;
   constructor(options: TransformOptions, comp: (a: T, b: T) => number);
-  _transform(data: T, _: BufferEncoding, callback: TransformCallback): void;
+  /** Collects each row as it arrives; nothing is emitted downstream yet. */
+  _transform(data: T, _encoding: BufferEncoding, callback: TransformCallback): void;
+  /** The source has ended - sort everything collected so far, then emit it all in order. */
   _flush(callback: TransformCallback): void;
 }
+/** Creates a sorting Transform: buffers every row, sorts by `comp`, and emits the result once the source ends. */
 export declare const sort: <T>(comp: (a: T, b: T) => number, options?: TransformOptions) => SortStreamer<T>;
 //#endregion

package/dist/stream/server/sort.mjs

@@ -1,40 +1,29 @@
 import { Transform } from "node:stream";
 //#region src/stream/server/sort.ts
-const batch = 15e3;
+/**
+* Buffers every row that passes through, then emits them all sorted by `comp` once the source ends.
+* Sorting requires seeing the whole collection first, so this is a full in-memory buffer - not a
+* bounded or windowed sort - and should only be used where the full stream fits comfortably in memory.
+*/
 var SortStreamer = class extends Transform {
-	a;
-	i;
-	k;
-	currentSize;
-	sortedArray;
+	rows = [];
 	comp;
 	constructor(options, comp) {
 		super(options);
-		this.a = new Array(batch);
-		this.i = 0;
-		this.k = 0;
-		this.currentSize = batch;
-		this.sortedArray = void 0;
 		this.comp = comp;
 	}
-	_transform(data, _, callback) {
-		if (data) {
-			this.a[this.i++] = data;
-			if (this.i === this.currentSize) {
-				this.currentSize *= 2;
-				const tmp = new Array(this.currentSize);
-				for (let j = 0; j < this.i; j++) tmp[j] = this.a[j];
-				this.a = tmp;
-			}
-		}
+	/** Collects each row as it arrives; nothing is emitted downstream yet. */
+	_transform(data, _encoding, callback) {
+		this.rows.push(data);
 		callback();
 	}
+	/** The source has ended - sort everything collected so far, then emit it all in order. */
 	_flush(callback) {
-		this.sortedArray = this.a.slice(0, this.i).sort(this.comp);
-		while (this.k < this.i) this.push(this.sortedArray[this.k++]);
+		this.rows.sort(this.comp).forEach((row) => this.push(row));
 		callback();
 	}
 };
+/** Creates a sorting Transform: buffers every row, sorts by `comp`, and emits the result once the source ends. */
 const sort = (comp, options) => {
 	return new SortStreamer(options ?? { objectMode: true }, comp);
 };

package/dist/xlsx/_shared/createXlsx.cjs

@@ -2,16 +2,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_xlsx__shared_column = require("./column.cjs");
 const require_xlsx__shared_cell = require("./cell.cjs");
 const require_xlsx__shared_sheet = require("./sheet.cjs");
+const require_zip__shared_ZipArchive = require("../../zip/_shared/ZipArchive.cjs");
 //#region src/xlsx/_shared/createXlsx.ts
 /**
-* Builds a complete .xlsx workbook from scratch, using jszip and hand-written
-* OOXML rather than a spreadsheet library.
+* Builds a complete .xlsx workbook from scratch, using hand-written OOXML rather
+* than a spreadsheet library.
 *
 * Nothing here touches `fs`, so it runs in the browser as happily as on the
 * server — a page can turn data it has already loaded straight into a download.
-*
-* jszip is an optional peer dependency imported dynamically, so consumers that
-* never build a workbook neither install it nor pay for it in their bundle.
 */
 /** Style index of the bold row within the cellXfs list built by buildStylesXml. */
 const HEADER_STYLE_INDEX = 1;
@@ -95,16 +93,15 @@ const buildPackageRelsXml = () => {
 */
 const buildWorkbook = async (sheets) => {
 	if (0 === sheets.length) throw new Error("createXlsx requires at least one sheet.");
-	const JSZip = (await import("jszip")).default;
-	const zip = new JSZip();
+	const zip = new require_zip__shared_ZipArchive.ZipArchive();
 	const names = require_xlsx__shared_sheet.getUniqueSheetNames(sheets);
-	zip.file("[Content_Types].xml", buildContentTypesXml(sheets.length));
-	zip.file("_rels/.rels", buildPackageRelsXml());
-	zip.file("xl/workbook.xml", buildWorkbookXml(names));
-	zip.file("xl/_rels/workbook.xml.rels", buildWorkbookRelsXml(sheets.length));
-	zip.file("xl/styles.xml", buildStylesXml());
+	zip.set("[Content_Types].xml", buildContentTypesXml(sheets.length));
+	zip.set("_rels/.rels", buildPackageRelsXml());
+	zip.set("xl/workbook.xml", buildWorkbookXml(names));
+	zip.set("xl/_rels/workbook.xml.rels", buildWorkbookRelsXml(sheets.length));
+	zip.set("xl/styles.xml", buildStylesXml());
 	sheets.forEach((sheet, index) => {
-		zip.file(`xl/worksheets/sheet${index + 1}.xml`, buildWorksheetXml(sheet));
+		zip.set(`xl/worksheets/sheet${index + 1}.xml`, buildWorksheetXml(sheet));
 	});
 	return zip;
 };
@@ -117,21 +114,14 @@ const buildWorkbook = async (sheets) => {
 * matter and a missing key becomes an empty cell.
 */
 const createXlsx = async (sheets) => {
-	return (await buildWorkbook(sheets)).generateAsync({
-		type: "blob",
-		compression: "DEFLATE",
-		mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-	});
+	return (await buildWorkbook(sheets)).toBlob("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
 };
 /**
 * As createXlsx, but returns raw bytes instead of a Blob — for server-side
 * callers that need to stream or write the workbook rather than download it.
 */
 const createXlsxBytes = async (sheets) => {
-	return (await buildWorkbook(sheets)).generateAsync({
-		type: "uint8array",
-		compression: "DEFLATE"
-	});
+	return (await buildWorkbook(sheets)).toBytes();
 };
 //#endregion
 exports.createXlsx = createXlsx;

package/dist/xlsx/_shared/createXlsx.mjs

@@ -1,16 +1,14 @@
 import { getColumLetter, getColumnWidth } from "./column.mjs";
 import { buildCellXml, getCellValue, getEscapedXml } from "./cell.mjs";
 import { getUniqueSheetNames } from "./sheet.mjs";
+import { ZipArchive } from "../../zip/_shared/ZipArchive.mjs";
 //#region src/xlsx/_shared/createXlsx.ts
 /**
-* Builds a complete .xlsx workbook from scratch, using jszip and hand-written
-* OOXML rather than a spreadsheet library.
+* Builds a complete .xlsx workbook from scratch, using hand-written OOXML rather
+* than a spreadsheet library.
 *
 * Nothing here touches `fs`, so it runs in the browser as happily as on the
 * server — a page can turn data it has already loaded straight into a download.
-*
-* jszip is an optional peer dependency imported dynamically, so consumers that
-* never build a workbook neither install it nor pay for it in their bundle.
 */
 /** Style index of the bold row within the cellXfs list built by buildStylesXml. */
 const HEADER_STYLE_INDEX = 1;
@@ -94,16 +92,15 @@ const buildPackageRelsXml = () => {
 */
 const buildWorkbook = async (sheets) => {
 	if (0 === sheets.length) throw new Error("createXlsx requires at least one sheet.");
-	const JSZip = (await import("jszip")).default;
-	const zip = new JSZip();
+	const zip = new ZipArchive();
 	const names = getUniqueSheetNames(sheets);
-	zip.file("[Content_Types].xml", buildContentTypesXml(sheets.length));
-	zip.file("_rels/.rels", buildPackageRelsXml());
-	zip.file("xl/workbook.xml", buildWorkbookXml(names));
-	zip.file("xl/_rels/workbook.xml.rels", buildWorkbookRelsXml(sheets.length));
-	zip.file("xl/styles.xml", buildStylesXml());
+	zip.set("[Content_Types].xml", buildContentTypesXml(sheets.length));
+	zip.set("_rels/.rels", buildPackageRelsXml());
+	zip.set("xl/workbook.xml", buildWorkbookXml(names));
+	zip.set("xl/_rels/workbook.xml.rels", buildWorkbookRelsXml(sheets.length));
+	zip.set("xl/styles.xml", buildStylesXml());
 	sheets.forEach((sheet, index) => {
-		zip.file(`xl/worksheets/sheet${index + 1}.xml`, buildWorksheetXml(sheet));
+		zip.set(`xl/worksheets/sheet${index + 1}.xml`, buildWorksheetXml(sheet));
 	});
 	return zip;
 };
@@ -116,21 +113,14 @@ const buildWorkbook = async (sheets) => {
 * matter and a missing key becomes an empty cell.
 */
 const createXlsx = async (sheets) => {
-	return (await buildWorkbook(sheets)).generateAsync({
-		type: "blob",
-		compression: "DEFLATE",
-		mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-	});
+	return (await buildWorkbook(sheets)).toBlob("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
 };
 /**
 * As createXlsx, but returns raw bytes instead of a Blob — for server-side
 * callers that need to stream or write the workbook rather than download it.
 */
 const createXlsxBytes = async (sheets) => {
-	return (await buildWorkbook(sheets)).generateAsync({
-		type: "uint8array",
-		compression: "DEFLATE"
-	});
+	return (await buildWorkbook(sheets)).toBytes();
 };
 //#endregion
 export { createXlsx, createXlsxBytes };