piclaw 0.0.4 → 0.0.6

package/.output/server/_libs/node-liblzma.mjs

@@ -0,0 +1,1107 @@
+import { createRequire } from "node:module";
+import { Transform } from "node:stream";
+import { createReadStream, createWriteStream } from "node:fs";
+import * as path$1 from "node:path";
+import * as os$1 from "node:os";
+import { pipeline as pipeline$1 } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import * as assert from "node:assert";
+import { EventEmitter } from "node:events";
+/**
+* node-liblzma - Node.js bindings for liblzma
+* Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/**
+* Base class for all LZMA-related errors
+*/
+var LZMAError = class extends Error {
+	constructor(message, errno) {
+		super(message);
+		this.name = "LZMAError";
+		this.errno = errno;
+		this.code = errno;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Memory allocation error - thrown when LZMA cannot allocate required memory
+*/
+var LZMAMemoryError = class extends LZMAError {
+	constructor(errno) {
+		super("Cannot allocate memory", errno);
+		this.name = "LZMAMemoryError";
+	}
+};
+/**
+* Memory limit error - thrown when operation would exceed memory usage limit
+*/
+var LZMAMemoryLimitError = class extends LZMAError {
+	constructor(errno) {
+		super("Memory usage limit was reached", errno);
+		this.name = "LZMAMemoryLimitError";
+	}
+};
+/**
+* Format error - thrown when file format is not recognized
+*/
+var LZMAFormatError = class extends LZMAError {
+	constructor(errno) {
+		super("File format not recognized", errno);
+		this.name = "LZMAFormatError";
+	}
+};
+/**
+* Options error - thrown when invalid or unsupported options are provided
+*/
+var LZMAOptionsError = class extends LZMAError {
+	constructor(errno) {
+		super("Invalid or unsupported options", errno);
+		this.name = "LZMAOptionsError";
+	}
+};
+/**
+* Data error - thrown when compressed data is corrupt
+*/
+var LZMADataError = class extends LZMAError {
+	constructor(errno) {
+		super("Data is corrupt", errno);
+		this.name = "LZMADataError";
+	}
+};
+/**
+* Buffer error - thrown when no progress is possible (e.g., buffer too small)
+*/
+var LZMABufferError = class extends LZMAError {
+	constructor(errno) {
+		super("No progress is possible", errno);
+		this.name = "LZMABufferError";
+	}
+};
+/**
+* Programming error - thrown when there's an internal programming error
+*/
+var LZMAProgrammingError = class extends LZMAError {
+	constructor(errno) {
+		super("Programming error", errno);
+		this.name = "LZMAProgrammingError";
+	}
+};
+/**
+* Factory function to create appropriate error instance based on errno
+*/
+function createLZMAError(errno, message) {
+	const LZMA_MEM_ERROR = 5;
+	const LZMA_MEMLIMIT_ERROR = 6;
+	const LZMA_FORMAT_ERROR = 7;
+	const LZMA_OPTIONS_ERROR = 8;
+	const LZMA_DATA_ERROR = 9;
+	const LZMA_BUF_ERROR = 10;
+	const LZMA_PROG_ERROR = 11;
+	switch (errno) {
+		case LZMA_MEM_ERROR: return new LZMAMemoryError(errno);
+		case LZMA_MEMLIMIT_ERROR: return new LZMAMemoryLimitError(errno);
+		case LZMA_FORMAT_ERROR: return new LZMAFormatError(errno);
+		case LZMA_OPTIONS_ERROR: return new LZMAOptionsError(errno);
+		case LZMA_DATA_ERROR: return new LZMADataError(errno);
+		case LZMA_BUF_ERROR: return new LZMABufferError(errno);
+		case LZMA_PROG_ERROR: return new LZMAProgrammingError(errno);
+		default: return new LZMAError(message || getErrorMessage(errno), errno);
+	}
+}
+/**
+* Get error message for a given errno
+*/
+function getErrorMessage(errno) {
+	const messages = [
+		"Operation completed successfully",
+		"End of stream was reached",
+		"Input stream has no integrity check",
+		"Cannot calculate the integrity check",
+		"Integrity check type is not available",
+		"Cannot allocate memory",
+		"Memory usage limit was reached",
+		"File format not recognized",
+		"Invalid or unsupported options",
+		"Data is corrupt",
+		"No progress is possible",
+		"Programming error"
+	];
+	if (errno < 0 || errno >= messages.length) return `Unknown LZMA error code: ${errno}`;
+	return messages[errno];
+}
+/**
+* node-liblzma - Node.js bindings for liblzma
+* Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/**
+* LZMA Pool with concurrency control and event monitoring
+*
+* Provides rate limiting and backpressure for LZMA operations.
+* Emits events for monitoring and metrics collection in production.
+*
+* @example
+* ```typescript
+* const pool = new LZMAPool(10); // Max 10 concurrent operations
+*
+* pool.on('metrics', (metrics) => {
+*   console.log(`Active: ${metrics.active}, Queued: ${metrics.queued}`);
+* });
+*
+* const compressed = await pool.compress(buffer);
+* ```
+*
+* Events:
+* - 'queue': Emitted when task added to queue
+* - 'start': Emitted when task starts processing
+* - 'complete': Emitted when task completes successfully
+* - 'error-task': Emitted when task fails
+* - 'metrics': Emitted after each state change with current metrics
+*/
+var LZMAPool = class extends EventEmitter {
+	/**
+	* Create a new LZMA pool
+	* @param maxConcurrent Maximum number of concurrent operations (default: 10)
+	*/
+	constructor(maxConcurrent = 10) {
+		super();
+		this.maxConcurrent = maxConcurrent;
+		this.queue = [];
+		this.metrics = {
+			active: 0,
+			queued: 0,
+			completed: 0,
+			failed: 0
+		};
+		if (maxConcurrent < 1) throw new RangeError("maxConcurrent must be at least 1");
+	}
+	/**
+	* Compress data with automatic queue management
+	* @param data Buffer to compress
+	* @param opts LZMA compression options
+	* @returns Promise that resolves to compressed buffer
+	*/
+	async compress(data, opts) {
+		return this.enqueue(() => xzAsync(data, opts));
+	}
+	/**
+	* Decompress data with automatic queue management
+	* @param data Compressed buffer to decompress
+	* @param opts LZMA decompression options
+	* @returns Promise that resolves to decompressed buffer
+	*/
+	async decompress(data, opts) {
+		return this.enqueue(() => unxzAsync(data, opts));
+	}
+	/**
+	* Get current pool metrics
+	* @returns Copy of current metrics
+	*/
+	getMetrics() {
+		return { ...this.metrics };
+	}
+	/**
+	* Get number of tasks waiting in queue
+	* @returns Queue length
+	*/
+	get queueLength() {
+		return this.queue.length;
+	}
+	/**
+	* Get number of currently active tasks
+	* @returns Active task count
+	*/
+	get activeCount() {
+		return this.metrics.active;
+	}
+	/**
+	* Check if pool is at maximum capacity
+	* @returns True if at capacity
+	*/
+	get isAtCapacity() {
+		return this.metrics.active >= this.maxConcurrent;
+	}
+	/**
+	* Enqueue a task for execution
+	* @param fn Task function returning Promise<Buffer>
+	* @returns Promise that resolves when task completes
+	*/
+	async enqueue(fn) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				fn,
+				resolve,
+				reject
+			});
+			this.metrics.queued = this.queue.length;
+			this.emit("queue", { ...this.metrics });
+			this.processQueue();
+		});
+	}
+	/**
+	* Process tasks from queue respecting concurrency limit
+	*/
+	processQueue() {
+		if (this.metrics.active >= this.maxConcurrent || this.queue.length === 0) return;
+		const item = this.queue.shift();
+		/* c8 ignore next - should never happen because we check queue length before */
+		if (!item) return;
+		this.metrics.active++;
+		this.metrics.queued = this.queue.length;
+		this.emit("start", { ...this.metrics });
+		Promise.resolve().then(() => item.fn()).then((result) => {
+			this.metrics.completed++;
+			item.resolve(result);
+			this.emit("complete", { ...this.metrics });
+		}).catch((error) => {
+			this.metrics.failed++;
+			item.reject(error);
+			this.emit("error-task", error, { ...this.metrics });
+		}).finally(() => {
+			this.metrics.active--;
+			this.emit("metrics", { ...this.metrics });
+			this.processQueue();
+		});
+	}
+	/**
+	* Wait for all active tasks to complete
+	* Does not process new tasks added while waiting
+	* @returns Promise that resolves when all active tasks are done
+	*/
+	async drain() {
+		if (this.metrics.active === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			const checkDrained = () => {
+				if (this.metrics.active === 0) {
+					this.off("metrics", checkDrained);
+					resolve();
+				}
+			};
+			this.on("metrics", checkDrained);
+		});
+	}
+	/**
+	* Clear all pending tasks from the queue
+	* Active tasks will continue to run
+	* @returns Number of tasks removed from queue
+	*/
+	clearQueue() {
+		const cleared = this.queue.length;
+		const error = /* @__PURE__ */ new Error("Task cancelled: queue cleared");
+		for (const task of this.queue) task.reject(error);
+		this.queue = [];
+		this.metrics.queued = 0;
+		this.emit("metrics", { ...this.metrics });
+		return cleared;
+	}
+};
+/**
+* node-liblzma - Node.js bindings for liblzma
+* Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path$1.dirname(__filename);
+var require = createRequire(import.meta.url);
+var bindingPath = path$1.resolve(path$1.join(__dirname, ".."));
+var liblzma = require("node-gyp-build")(bindingPath);
+var maxThreads = os$1.cpus().length;
+/**
+* Integrity check types for XZ streams.
+* Use CRC64 for best balance of speed and error detection.
+* @example
+* ```ts
+* const compressor = createXz({ check: check.CRC64 });
+* ```
+*/
+const check = {
+	NONE: liblzma.LZMA_CHECK_NONE,
+	CRC32: liblzma.LZMA_CHECK_CRC32,
+	CRC64: liblzma.LZMA_CHECK_CRC64,
+	SHA256: liblzma.LZMA_CHECK_SHA256
+};
+/**
+* Compression preset flags.
+* Can be combined with preset level using bitwise OR.
+* @example
+* ```ts
+* const compressor = createXz({ preset: 6 | preset.EXTREME });
+* ```
+*/
+const preset = {
+	DEFAULT: liblzma.LZMA_PRESET_DEFAULT,
+	EXTREME: liblzma.LZMA_PRESET_EXTREME
+};
+/**
+* Decoder flags for controlling decompression behavior.
+* @example
+* ```ts
+* const decompressor = createUnxz({ flushFlag: flag.CONCATENATED });
+* ```
+*/
+const flag = {
+	TELL_NO_CHECK: liblzma.LZMA_TELL_NO_CHECK,
+	TELL_UNSUPPORTED_CHECK: liblzma.LZMA_TELL_UNSUPPORTED_CHECK,
+	TELL_ANY_CHECK: liblzma.LZMA_TELL_ANY_CHECK,
+	CONCATENATED: liblzma.LZMA_CONCATENATED
+};
+/**
+* Compression filters for preprocessing data before LZMA2.
+* BCJ filters improve compression for executable code.
+* @example
+* ```ts
+* // Compress x86 executable with BCJ filter
+* const compressor = createXz({ filters: [filter.X86, filter.LZMA2] });
+* ```
+*/
+const filter = {
+	LZMA2: liblzma.LZMA_FILTER_LZMA2,
+	X86: liblzma.LZMA_FILTER_X86,
+	POWERPC: liblzma.LZMA_FILTER_POWERPC,
+	IA64: liblzma.LZMA_FILTER_IA64,
+	ARM: liblzma.LZMA_FILTER_ARM,
+	ARMTHUMB: liblzma.LZMA_FILTER_ARMTHUMB,
+	SPARC: liblzma.LZMA_FILTER_SPARC
+};
+/* v8 ignore next */
+/**
+* Compression mode selection.
+* FAST uses less memory, NORMAL provides better compression.
+*/
+const mode = {
+	FAST: liblzma.LZMA_MODE_FAST,
+	NORMAL: liblzma.LZMA_MODE_NORMAL
+};
+/* v8 ignore next 2 */
+/**
+* LZMA stream action constants.
+* Control how the encoder/decoder processes input.
+*/
+const LZMAAction = {
+	RUN: liblzma.LZMA_RUN,
+	SYNC_FLUSH: liblzma.LZMA_SYNC_FLUSH,
+	FULL_FLUSH: liblzma.LZMA_FULL_FLUSH,
+	FINISH: liblzma.LZMA_FINISH
+};
+/* v8 ignore next 2 */
+/**
+* LZMA operation status/return codes.
+* Used to indicate the result of encoding/decoding operations.
+*/
+const LZMAStatus = {
+	OK: liblzma.LZMA_OK,
+	STREAM_END: liblzma.LZMA_STREAM_END,
+	NO_CHECK: liblzma.LZMA_NO_CHECK,
+	UNSUPPORTED_CHECK: liblzma.LZMA_UNSUPPORTED_CHECK,
+	GET_CHECK: liblzma.LZMA_GET_CHECK,
+	MEM_ERROR: liblzma.LZMA_MEM_ERROR,
+	MEMLIMIT_ERROR: liblzma.LZMA_MEMLIMIT_ERROR,
+	FORMAT_ERROR: liblzma.LZMA_FORMAT_ERROR,
+	OPTIONS_ERROR: liblzma.LZMA_OPTIONS_ERROR,
+	DATA_ERROR: liblzma.LZMA_DATA_ERROR,
+	BUF_ERROR: liblzma.LZMA_BUF_ERROR,
+	PROG_ERROR: liblzma.LZMA_PROG_ERROR
+};
+const LZMAFilter = {
+	...filter,
+	X86_ALT: liblzma.LZMA_FILTER_X86,
+	POWERPC_ALT: liblzma.LZMA_FILTER_POWERPC,
+	IA64_ALT: liblzma.LZMA_FILTER_IA64,
+	ARM_ALT: liblzma.LZMA_FILTER_ARM,
+	ARMTHUMB_ALT: liblzma.LZMA_FILTER_ARMTHUMB,
+	FILTERS_MAX: liblzma.LZMA_FILTERS_MAX
+};
+const LZMA_RUN = LZMAAction.RUN;
+const LZMA_SYNC_FLUSH = LZMAAction.SYNC_FLUSH;
+const LZMA_FULL_FLUSH = LZMAAction.FULL_FLUSH;
+const LZMA_FINISH = LZMAAction.FINISH;
+const LZMA_OK = LZMAStatus.OK;
+const LZMA_STREAM_END = LZMAStatus.STREAM_END;
+const LZMA_NO_CHECK = LZMAStatus.NO_CHECK;
+const LZMA_UNSUPPORTED_CHECK = LZMAStatus.UNSUPPORTED_CHECK;
+const LZMA_GET_CHECK = LZMAStatus.GET_CHECK;
+const LZMA_MEM_ERROR = LZMAStatus.MEM_ERROR;
+const LZMA_MEMLIMIT_ERROR = LZMAStatus.MEMLIMIT_ERROR;
+const LZMA_FORMAT_ERROR = LZMAStatus.FORMAT_ERROR;
+const LZMA_OPTIONS_ERROR = LZMAStatus.OPTIONS_ERROR;
+const LZMA_DATA_ERROR = LZMAStatus.DATA_ERROR;
+const LZMA_BUF_ERROR = LZMAStatus.BUF_ERROR;
+const LZMA_PROG_ERROR = LZMAStatus.PROG_ERROR;
+const LZMA_FILTER_X86 = LZMAFilter.X86_ALT;
+const LZMA_FILTER_POWERPC = LZMAFilter.POWERPC_ALT;
+const LZMA_FILTER_IA64 = LZMAFilter.IA64_ALT;
+const LZMA_FILTER_ARM = LZMAFilter.ARM_ALT;
+const LZMA_FILTER_ARMTHUMB = LZMAFilter.ARMTHUMB_ALT;
+const LZMA_FILTERS_MAX = LZMAFilter.FILTERS_MAX;
+/**
+* Abstract base class for XZ compression/decompression streams.
+* Extends Node.js Transform stream with LZMA2 encoding/decoding.
+*
+* @example
+* ```ts
+* // Use Xz or Unxz classes instead of XzStream directly
+* const compressor = new Xz({ preset: 6 });
+* readStream.pipe(compressor).pipe(writeStream);
+* ```
+*
+* Emits `progress` event after each chunk with `{bytesRead, bytesWritten}` info.
+*/
+var XzStream = class extends Transform {
+	constructor(streamMode, opts = {}, options) {
+		super(options);
+		let clonedFilters;
+		if (opts.filters) {
+			if (!Array.isArray(opts.filters)) throw new Error("Filters need to be in an array!");
+			try {
+				clonedFilters = [...opts.filters];
+			} catch (_error) {
+				throw new Error("Filters need to be in an array!");
+			}
+		} else clonedFilters = [filter.LZMA2];
+		this._opts = {
+			check: opts.check ?? check.NONE,
+			preset: opts.preset ?? preset.DEFAULT,
+			filters: clonedFilters,
+			mode: opts.mode ?? mode.NORMAL,
+			threads: opts.threads ?? 1,
+			chunkSize: opts.chunkSize ?? liblzma.BUFSIZ,
+			flushFlag: opts.flushFlag ?? liblzma.LZMA_RUN
+		};
+		this._chunkSize = this._opts.chunkSize;
+		this._flushFlag = this._opts.flushFlag;
+		assert.ok(Array.isArray(this._opts.filters), "Filters need to be in an array!");
+		/* v8 ignore next 2 */
+		if (this._opts.filters.indexOf(filter.LZMA2) === -1) this._opts.filters.push(filter.LZMA2);
+		const lzma2Index = this._opts.filters.indexOf(filter.LZMA2);
+		if (lzma2Index !== -1 && lzma2Index !== this._opts.filters.length - 1) {
+			this._opts.filters.splice(lzma2Index, 1);
+			this._opts.filters.push(filter.LZMA2);
+		}
+		if (streamMode === liblzma.STREAM_ENCODE) {
+			/* c8 ignore start */
+			if (!liblzma.HAS_THREADS_SUPPORT) this._opts.threads = 1;
+			/* c8 ignore stop */
+			if (this._opts.threads === 0) this._opts.threads = maxThreads;
+		}
+		this.lzma = new liblzma.LZMA(streamMode, this._opts);
+		this._closed = false;
+		this._hadError = false;
+		this._offset = 0;
+		this._buffer = Buffer.alloc(this._chunkSize);
+		this._bytesRead = 0;
+		this._bytesWritten = 0;
+		/* v8 ignore next */
+		this.on("onerror", (errno) => {
+			this._hadError = true;
+			const error = this._createLZMAError(errno);
+			this.emit("error", error);
+		});
+		/* v8 ignore next */
+		this.once("end", () => this.close());
+	}
+	_createLZMAError(errno) {
+		return createLZMAError(errno);
+	}
+	/** Get total bytes read from input so far */
+	get bytesRead() {
+		return this._bytesRead;
+	}
+	/** Get total bytes written to output so far */
+	get bytesWritten() {
+		return this._bytesWritten;
+	}
+	/**
+	* Emit a progress event with current bytesRead and bytesWritten
+	*/
+	_emitProgress() {
+		const info = {
+			bytesRead: this._bytesRead,
+			bytesWritten: this._bytesWritten
+		};
+		this.emit("progress", info);
+	}
+	_reallocateBuffer() {
+		this._offset = 0;
+		this._buffer = Buffer.alloc(this._chunkSize);
+	}
+	flush(kindOrCallback, callback) {
+		const ws = this._writableState;
+		let kind;
+		let cb;
+		/* v8 ignore next */
+		if (typeof kindOrCallback === "function" || typeof kindOrCallback === "undefined" && !callback) {
+			cb = kindOrCallback;
+			kind = liblzma.LZMA_SYNC_FLUSH;
+		} else {
+			kind = kindOrCallback;
+			cb = callback;
+		}
+		if (ws.ended) {
+			if (cb) process.nextTick(cb);
+		} else if (ws.ending) {
+			if (cb) this.once("end", cb);
+		} else if (ws.needDrain) this.once("drain", () => {
+			this.flush(cb);
+		});
+		else {
+			this._flushFlag = kind;
+			this.write(Buffer.alloc(0), "utf8", cb);
+		}
+	}
+	close(callback) {
+		if (callback) process.nextTick(callback);
+		if (this._closed) return;
+		/* v8 ignore next */
+		this.lzma.close();
+		this._closed = true;
+		/* v8 ignore next */
+		process.nextTick(() => {
+			this.emit("close");
+		});
+	}
+	/* v8 ignore next */
+	_transform(chunk, _encoding, callback) {
+		const ws = this._writableState;
+		const last = (ws.ending || ws.ended) && (!chunk || ws.length === chunk.length);
+		if (chunk !== null && !(chunk instanceof Buffer)) {
+			callback(/* @__PURE__ */ new Error("invalid input"));
+			return;
+		}
+		if (this._closed) {
+			callback(/* @__PURE__ */ new Error("lzma binding closed"));
+			return;
+		}
+		if (chunk) this._bytesRead += chunk.length;
+		/* v8 ignore next */
+		let flushFlag;
+		if (last) flushFlag = liblzma.LZMA_FINISH;
+		else {
+			flushFlag = this._flushFlag;
+			if (chunk && chunk.length >= ws.length) this._flushFlag = this._opts.flushFlag;
+		}
+		/* v8 ignore next */
+		this._processChunk(chunk, flushFlag, callback);
+	}
+	_flush(callback) {
+		/* v8 ignore next 4 - Defensive check for double close scenario */
+		if (this._closed) {
+			process.nextTick(() => callback());
+			return;
+		}
+		this._transform(Buffer.alloc(0), "utf8", callback);
+	}
+	_processChunk(chunk, flushFlag, cb) {
+		const async = typeof cb === "function";
+		assert.ok(!this._closed, "Stream closed!");
+		let availInBefore = chunk?.length;
+		let availOutBefore = this._chunkSize - this._offset;
+		let inOff = 0;
+		/* v8 ignore next 3 */
+		if (!async) {
+			const buffers = [];
+			let nread = 0;
+			let error = null;
+			/* v8 ignore next */
+			const callback = (errno, availInAfter, availOutAfter) => {
+				/* v8 ignore start */
+				if (this._hadError) return false;
+				if (errno !== liblzma.LZMA_OK && errno !== liblzma.LZMA_STREAM_END) {
+					this.emit("onerror", errno);
+					return false;
+				}
+				/* v8 ignore stop */
+				const used = availOutBefore - availOutAfter;
+				assert.ok(used >= 0, `More bytes after than before! Delta = ${used}`);
+				if (used > 0) {
+					const out = this._buffer.subarray(this._offset, this._offset + used);
+					this._offset += used;
+					buffers.push(out);
+					nread += used;
+				}
+				/* v8 ignore start */
+				if (availOutAfter === 0 || this._offset >= this._chunkSize) {
+					availOutBefore = this._chunkSize;
+					this._reallocateBuffer();
+				}
+				if (availOutAfter === 0 || availInAfter > 0) {
+					inOff += (availInBefore ?? 0) - availInAfter;
+					availInBefore = availInAfter;
+					return true;
+				}
+				/* v8 ignore stop */
+				return false;
+			};
+			/* v8 ignore start */
+			this.on("error", (e) => {
+				error = e;
+			});
+			/* v8 ignore stop */
+			/* v8 ignore next - processing loop entry */
+			while (true) {
+				const [status, availInAfter, availOutAfter] = this.lzma.codeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset);
+				/* v8 ignore start */
+				if (this._hadError || !callback(status, availInAfter, availOutAfter)) break;
+			}
+			try {
+				/* v8 ignore start */
+				if (this._hadError) throw error ?? /* @__PURE__ */ new Error("Unknown LZMA error");
+				return Buffer.concat(buffers, nread);
+			} finally {
+				/* v8 ignore next - cleanup path */
+				this.close();
+			}
+		}
+		const callback = (errno, availInAfter, availOutAfter) => {
+			/* v8 ignore next 3 - error state handling is difficult to test */
+			if (this._hadError) return false;
+			/* v8 ignore next 5 - async error path handling */
+			if (errno !== liblzma.LZMA_OK && errno !== liblzma.LZMA_STREAM_END) {
+				this.emit("onerror", errno);
+				return false;
+			}
+			/* v8 ignore next */
+			const used = availOutBefore - availOutAfter;
+			assert.ok(used >= 0, `More bytes after than before! Delta = ${used}`);
+			if (used > 0) {
+				const out = this._buffer.subarray(this._offset, this._offset + used);
+				this._offset += used;
+				this._bytesWritten += used;
+				this.push(out);
+				this._emitProgress();
+			}
+			if (availOutAfter === 0 || this._offset >= this._chunkSize) {
+				availOutBefore = this._chunkSize;
+				this._reallocateBuffer();
+			}
+			if (availOutAfter === 0 || availInAfter > 0) {
+				/* v8 ignore next 2 - complex async processing continuation */
+				inOff += (availInBefore ?? 0) - availInAfter;
+				availInBefore = availInAfter;
+				this.lzma.code(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, callback);
+				return false;
+			}
+			if (cb && !this._closed) try {
+				cb();
+			} catch (_error) {
+				this.emit("onerror", liblzma.LZMA_PROG_ERROR);
+			}
+			return false;
+		};
+		this.lzma.code(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, callback);
+	}
+};
+/**
+* XZ compression stream.
+* Compresses data using LZMA2 algorithm.
+*
+* @example
+* ```ts
+* const compressor = new Xz({ preset: 6 });
+* input.pipe(compressor).pipe(output);
+* ```
+*/
+var Xz = class extends XzStream {
+	constructor(lzmaOptions, options) {
+		super(liblzma.STREAM_ENCODE, lzmaOptions, options);
+	}
+};
+/**
+* XZ decompression stream.
+* Decompresses data compressed with XZ/LZMA2.
+*
+* @example
+* ```ts
+* const decompressor = new Unxz();
+* compressedInput.pipe(decompressor).pipe(output);
+* ```
+*/
+var Unxz = class extends XzStream {
+	constructor(lzmaOptions, options) {
+		super(liblzma.STREAM_DECODE, lzmaOptions, options);
+	}
+};
+/* v8 ignore next */
+/**
+* Create a new XZ compression stream.
+* @param lzmaOptions - LZMA compression options
+* @param options - Node.js Transform stream options
+* @returns New Xz compression stream
+*
+* @example
+* ```ts
+* const compressor = createXz({ preset: 9 });
+* ```
+*/
+function createXz(lzmaOptions, options) {
+	return new Xz(lzmaOptions, options);
+}
+/* v8 ignore next */
+/**
+* Create a new XZ decompression stream.
+* @param lzmaOptions - LZMA decompression options
+* @param options - Node.js Transform stream options
+* @returns New Unxz decompression stream
+*
+* @example
+* ```ts
+* const decompressor = createUnxz();
+* ```
+*/
+function createUnxz(lzmaOptions, options) {
+	return new Unxz(lzmaOptions, options);
+}
+/* v8 ignore next */
+/**
+* Check if liblzma was built with threading support.
+* @returns true if multi-threaded compression is available
+*/
+function hasThreads() {
+	return liblzma.HAS_THREADS_SUPPORT;
+}
+/**
+* Check if a buffer contains XZ compressed data by examining magic bytes.
+* @param buffer - Buffer to check (needs at least 6 bytes)
+* @returns true if the buffer starts with XZ magic bytes
+* @example
+* ```ts
+* const compressed = await xzAsync(Buffer.from('Hello'));
+* console.log(isXZ(compressed)); // true
+* console.log(isXZ(Buffer.from('Hello'))); // false
+* ```
+*/
+function isXZ(buffer) {
+	return liblzma.isXZ(buffer);
+}
+/**
+* Get the runtime version of liblzma as a string.
+* @returns Version string like "5.4.1"
+* @example
+* ```ts
+* console.log(versionString()); // "5.4.1"
+* ```
+*/
+function versionString() {
+	return liblzma.versionString();
+}
+/**
+* Get the runtime version of liblzma as a number.
+* Format: MAJOR * 10000000 + MINOR * 10000 + PATCH * 10
+* @returns Version number (e.g., 50040010 for 5.4.1)
+* @example
+* ```ts
+* console.log(versionNumber()); // 50040010
+* ```
+*/
+function versionNumber() {
+	return liblzma.versionNumber();
+}
+/**
+* Get the memory usage estimate for encoding with a given preset.
+* @param presetLevel - Compression preset (0-9, optionally OR'd with preset.EXTREME)
+* @returns Memory usage in bytes, or 0 if preset is invalid
+* @example
+* ```ts
+* console.log(easyEncoderMemusage(6)); // ~104857600 (100 MB)
+* console.log(easyEncoderMemusage(9 | preset.EXTREME)); // ~712507392 (680 MB)
+* ```
+*/
+function easyEncoderMemusage(presetLevel) {
+	return liblzma.easyEncoderMemusage(presetLevel);
+}
+/**
+* Get the memory usage estimate for decoding.
+* @returns Memory usage in bytes for decoder initialization
+* @example
+* ```ts
+* console.log(easyDecoderMemusage()); // ~18874368 (18 MB)
+* ```
+*/
+function easyDecoderMemusage() {
+	return liblzma.easyDecoderMemusage();
+}
+/**
+* Parse the index from a complete XZ file buffer to get metadata.
+* This allows you to know the uncompressed size before decompressing.
+* @param buffer - Complete XZ file buffer
+* @returns Object with file metadata
+* @throws Error if buffer is not a valid XZ stream
+* @example
+* ```ts
+* const compressed = await xzAsync(largeBuffer);
+* const info = parseFileIndex(compressed);
+* console.log(`Uncompressed: ${info.uncompressedSize}, Compressed: ${info.compressedSize}`);
+* console.log(`Ratio: ${(info.compressedSize / info.uncompressedSize * 100).toFixed(1)}%`);
+* ```
+*/
+function parseFileIndex(buffer) {
+	return liblzma.parseFileIndex(buffer);
+}
+/* v8 ignore next */
+/**
+* Human-readable error messages for LZMA status codes.
+*/
+var LZMAErrorMessage;
+(function(LZMAErrorMessage) {
+	LZMAErrorMessage["SUCCESS"] = "Operation completed successfully";
+	LZMAErrorMessage["STREAM_END"] = "End of stream was reached";
+	LZMAErrorMessage["NO_CHECK"] = "Input stream has no integrity check";
+	LZMAErrorMessage["UNSUPPORTED_CHECK"] = "Cannot calculate the integrity check";
+	LZMAErrorMessage["GET_CHECK"] = "Integrity check type is not available";
+	LZMAErrorMessage["MEM_ERROR"] = "Cannot allocate memory";
+	LZMAErrorMessage["MEMLIMIT_ERROR"] = "Memory usage limit was reached";
+	LZMAErrorMessage["FORMAT_ERROR"] = "File format not recognized";
+	LZMAErrorMessage["OPTIONS_ERROR"] = "Invalid or unsupported options";
+	LZMAErrorMessage["DATA_ERROR"] = "Data is corrupt";
+	LZMAErrorMessage["BUF_ERROR"] = "No progress is possible";
+	LZMAErrorMessage["PROG_ERROR"] = "Programming error";
+})(LZMAErrorMessage || (LZMAErrorMessage = {}));
+/**
+* Array of error messages indexed by LZMA status code.
+* @deprecated Use LZMAErrorMessage enum instead
+*/
+const messages = [
+	LZMAErrorMessage.SUCCESS,
+	LZMAErrorMessage.STREAM_END,
+	LZMAErrorMessage.NO_CHECK,
+	LZMAErrorMessage.UNSUPPORTED_CHECK,
+	LZMAErrorMessage.GET_CHECK,
+	LZMAErrorMessage.MEM_ERROR,
+	LZMAErrorMessage.MEMLIMIT_ERROR,
+	LZMAErrorMessage.FORMAT_ERROR,
+	LZMAErrorMessage.OPTIONS_ERROR,
+	LZMAErrorMessage.DATA_ERROR,
+	LZMAErrorMessage.BUF_ERROR,
+	LZMAErrorMessage.PROG_ERROR
+];
+function unxz(buffer, optsOrCallback, callback) {
+	let opts;
+	let cb;
+	/* v8 ignore next - simple parameter parsing */
+	if (typeof optsOrCallback === "function") {
+		cb = optsOrCallback;
+		opts = {};
+	} else {
+		opts = optsOrCallback;
+		cb = callback;
+	}
+	xzBuffer(new Unxz(opts), buffer, cb);
+}
+/**
+* Decompress a buffer synchronously.
+* @param buffer - Compressed data to decompress
+* @param opts - LZMA decompression options
+* @returns Decompressed data buffer
+*
+* @example
+* ```ts
+* const decompressed = unxzSync(compressedBuffer);
+* ```
+*/
+function unxzSync(buffer, opts) {
+	return xzBufferSync(new Unxz(opts), buffer);
+}
+function xz(buffer, optsOrCallback, callback) {
+	let opts;
+	let cb;
+	/* v8 ignore next - simple parameter parsing */
+	if (typeof optsOrCallback === "function") {
+		cb = optsOrCallback;
+		opts = {};
+	} else {
+		opts = optsOrCallback;
+		cb = callback;
+	}
+	xzBuffer(new Xz(opts), buffer, cb);
+}
+/**
+* Compress a buffer synchronously.
+* @param buffer - Data to compress
+* @param opts - LZMA compression options
+* @returns Compressed data buffer
+*
+* @example
+* ```ts
+* const compressed = xzSync(data, { preset: 9 });
+* ```
+*/
+function xzSync(buffer, opts) {
+	return xzBufferSync(new Xz(opts), buffer);
+}
+/**
+* Compress a buffer asynchronously using Promise.
+* @param buffer - Data to compress
+* @param opts - LZMA compression options
+* @returns Promise resolving to compressed data buffer
+*
+* @example
+* ```ts
+* const compressed = await xzAsync(data, { preset: 6 });
+* ```
+*/
+function xzAsync(buffer, opts) {
+	return new Promise((resolve, reject) => {
+		xz(buffer, opts || {}, (error, result) => {
+			/* v8 ignore next 3 - error handling is tested in callback-based tests */
+			if (error) reject(error);
+			else resolve(result);
+		});
+	});
+}
+/**
+* Decompress a buffer asynchronously using Promise.
+* @param buffer - Compressed data to decompress
+* @param opts - LZMA decompression options
+* @returns Promise resolving to decompressed data buffer
+*
+* @example
+* ```ts
+* const decompressed = await unxzAsync(compressedBuffer);
+* console.log(decompressed.toString());
+* ```
+*/
+function unxzAsync(buffer, opts) {
+	return new Promise((resolve, reject) => {
+		unxz(buffer, opts || {}, (error, result) => {
+			/* v8 ignore next 2 - error handling is tested in callback-based tests */
+			if (error) reject(error);
+			else resolve(result);
+		});
+	});
+}
+function xzBuffer(engine, buffer, callback) {
+	const buffers = [];
+	let nread = 0;
+	const flow = () => {
+		let chunk;
+		while ((chunk = engine.read()) !== null) {
+			buffers.push(chunk);
+			nread += chunk.length;
+		}
+		engine.once("readable", flow);
+	};
+	const onEnd = () => {
+		callback(null, Buffer.concat(buffers, nread));
+		engine.close();
+	};
+	/* v8 ignore next 5 - error callback path */
+	const onError = (err) => {
+		engine.removeListener("end", onEnd);
+		engine.removeListener("readable", flow);
+		callback(err);
+	};
+	engine.on("error", onError);
+	engine.on("end", onEnd);
+	engine.end(buffer);
+	flow();
+}
+function xzBufferSync(engine, buffer) {
+	let buf;
+	if (typeof buffer === "string") buf = Buffer.from(buffer);
+	else if (buffer instanceof Buffer) buf = buffer;
+	else throw new TypeError("Not a string or buffer");
+	return engine._processChunk(buf, liblzma.LZMA_FINISH);
+}
+/**
+* Compress a file using XZ compression
+* @param inputPath Path to input file
+* @param outputPath Path to output compressed file
+* @param opts LZMA compression options
+* @returns Promise that resolves when compression is complete
+*/
+async function xzFile(inputPath, outputPath, opts) {
+	const input = createReadStream(inputPath);
+	const output = createWriteStream(outputPath);
+	await pipeline$1(input, createXz(opts), output);
+}
+/**
+* Decompress an XZ compressed file
+* @param inputPath Path to compressed input file
+* @param outputPath Path to output decompressed file
+* @param opts LZMA decompression options
+* @returns Promise that resolves when decompression is complete
+*/
+async function unxzFile(inputPath, outputPath, opts) {
+	const input = createReadStream(inputPath);
+	const output = createWriteStream(outputPath);
+	await pipeline$1(input, createUnxz(opts), output);
+}
+var lzma_default = {
+	Xz,
+	Unxz,
+	XzStream,
+	hasThreads,
+	messages,
+	check,
+	preset,
+	flag,
+	filter,
+	mode,
+	createXz,
+	createUnxz,
+	unxz,
+	unxzSync,
+	xz,
+	xzSync,
+	xzAsync,
+	unxzAsync,
+	LZMA_RUN,
+	LZMA_SYNC_FLUSH,
+	LZMA_FULL_FLUSH,
+	LZMA_FINISH,
+	LZMA_OK,
+	LZMA_STREAM_END,
+	LZMA_NO_CHECK,
+	LZMA_UNSUPPORTED_CHECK,
+	LZMA_GET_CHECK,
+	LZMA_MEM_ERROR,
+	LZMA_MEMLIMIT_ERROR,
+	LZMA_FORMAT_ERROR,
+	LZMA_OPTIONS_ERROR,
+	LZMA_DATA_ERROR,
+	LZMA_BUF_ERROR,
+	LZMA_PROG_ERROR,
+	LZMA_FILTER_X86,
+	LZMA_FILTER_POWERPC,
+	LZMA_FILTER_IA64,
+	LZMA_FILTER_ARM,
+	LZMA_FILTER_ARMTHUMB,
+	LZMA_FILTERS_MAX
+};
+export { xzSync as $, check as A, messages as B, LZMA_RUN as C, Unxz as D, LZMA_UNSUPPORTED_CHECK as E, filter as F, unxzAsync as G, parseFileIndex as H, flag as I, versionNumber as J, unxzFile as K, hasThreads as L, createXz as M, easyDecoderMemusage as N, Xz as O, easyEncoderMemusage as P, xzFile as Q, isXZ as R, LZMA_PROG_ERROR as S, LZMA_SYNC_FLUSH as T, preset as U, mode as V, unxz as W, xz as X, versionString as Y, xzAsync as Z, LZMA_MEMLIMIT_ERROR as _, LZMA_BUF_ERROR as a, LZMAMemoryError as at, LZMA_OK as b, LZMA_FILTER_ARM as c, LZMAProgrammingError as ct, LZMA_FILTER_POWERPC as d, LZMAPool as et, LZMA_FILTER_X86 as f, LZMA_GET_CHECK as g, LZMA_FULL_FLUSH as h, LZMAStatus as i, LZMAFormatError as it, createUnxz as j, XzStream as k, LZMA_FILTER_ARMTHUMB as l, LZMA_FORMAT_ERROR as m, LZMAErrorMessage as n, LZMADataError as nt, LZMA_DATA_ERROR as o, LZMAMemoryLimitError as ot, LZMA_FINISH as p, unxzSync as q, LZMAFilter as r, LZMAError as rt, LZMA_FILTERS_MAX as s, LZMAOptionsError as st, LZMAAction as t, LZMABufferError as tt, LZMA_FILTER_IA64 as u, LZMA_MEM_ERROR as v, LZMA_STREAM_END as w, LZMA_OPTIONS_ERROR as x, LZMA_NO_CHECK as y, lzma_default as z };