@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/lzma-xM_ySpEU.cjs

@@ -0,0 +1,1204 @@
+const require_chunk = require("./chunk-emK7D4bc.cjs");
+let node_module = require("node:module");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let node_url = require("node:url");
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os, 1);
+let node_assert = require("node:assert");
+node_assert = require_chunk.__toESM(node_assert, 1);
+let node_stream = require("node:stream");
+let node_events = require("node:events");
+let node_stream_promises = require("node:stream/promises");
+//#region ../../node_modules/.pnpm/node-liblzma@2.2.0/node_modules/node-liblzma/lib/errors.js
+/**
+* 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];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/node-liblzma@2.2.0/node_modules/node-liblzma/lib/pool.js
+/**
+* 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 node_events.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;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/node-liblzma@2.2.0/node_modules/node-liblzma/lib/lzma.js
+/**
+* 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/>.
+*/
+const __filename$1 = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+const __dirname$1 = node_path.dirname(__filename$1);
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const bindingPath = node_path.resolve(node_path.join(__dirname$1, ".."));
+const liblzma = require$1("node-gyp-build")(bindingPath);
+const maxThreads = node_os.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 compression level (6) */
+	DEFAULT: liblzma.LZMA_PRESET_DEFAULT,
+	/** Extreme mode flag - slower but better compression */
+	EXTREME: liblzma.LZMA_PRESET_EXTREME
+};
+/**
+* Decoder flags for controlling decompression behavior.
+* @example
+* ```ts
+* const decompressor = createUnxz({ flushFlag: flag.CONCATENATED });
+* ```
+*/
+const flag = {
+	/** Tell decoder if input has no integrity check */
+	TELL_NO_CHECK: liblzma.LZMA_TELL_NO_CHECK,
+	/** Tell decoder if integrity check is unsupported */
+	TELL_UNSUPPORTED_CHECK: liblzma.LZMA_TELL_UNSUPPORTED_CHECK,
+	/** Tell decoder about any integrity check type */
+	TELL_ANY_CHECK: liblzma.LZMA_TELL_ANY_CHECK,
+	/** Allow concatenated XZ streams */
+	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 compression filter (required, must be last) */
+	LZMA2: liblzma.LZMA_FILTER_LZMA2,
+	/** BCJ filter for x86 executables */
+	X86: liblzma.LZMA_FILTER_X86,
+	/** BCJ filter for PowerPC executables */
+	POWERPC: liblzma.LZMA_FILTER_POWERPC,
+	/** BCJ filter for IA-64 executables */
+	IA64: liblzma.LZMA_FILTER_IA64,
+	/** BCJ filter for ARM executables */
+	ARM: liblzma.LZMA_FILTER_ARM,
+	/** BCJ filter for ARM-Thumb executables */
+	ARMTHUMB: liblzma.LZMA_FILTER_ARMTHUMB,
+	/** BCJ filter for SPARC executables */
+	SPARC: liblzma.LZMA_FILTER_SPARC
+};
+/* v8 ignore next */
+/**
+* Compression mode selection.
+* FAST uses less memory, NORMAL provides better compression.
+*/
+const mode = {
+	/** Fast compression mode - less memory, faster */
+	FAST: liblzma.LZMA_MODE_FAST,
+	/** Normal compression mode - better ratio */
+	NORMAL: liblzma.LZMA_MODE_NORMAL
+};
+/* v8 ignore next 2 */
+/**
+* LZMA stream action constants.
+* Control how the encoder/decoder processes input.
+*/
+const LZMAAction = {
+	/** Normal processing - continue encoding/decoding */
+	RUN: liblzma.LZMA_RUN,
+	/** Flush pending output synchronously */
+	SYNC_FLUSH: liblzma.LZMA_SYNC_FLUSH,
+	/** Flush and reset encoder state */
+	FULL_FLUSH: liblzma.LZMA_FULL_FLUSH,
+	/** Finish the stream - no more input */
+	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 node_stream.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;
+		node_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";
+		node_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;
+				node_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;
+			node_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 = (0, node_fs.createReadStream)(inputPath);
+	const output = (0, node_fs.createWriteStream)(outputPath);
+	await (0, node_stream_promises.pipeline)(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 = (0, node_fs.createReadStream)(inputPath);
+	const output = (0, node_fs.createWriteStream)(outputPath);
+	await (0, node_stream_promises.pipeline)(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
+};
+//#endregion
+exports.LZMAAction = LZMAAction;
+exports.LZMABufferError = LZMABufferError;
+exports.LZMADataError = LZMADataError;
+exports.LZMAError = LZMAError;
+Object.defineProperty(exports, "LZMAErrorMessage", {
+	enumerable: true,
+	get: function() {
+		return LZMAErrorMessage;
+	}
+});
+exports.LZMAFilter = LZMAFilter;
+exports.LZMAFormatError = LZMAFormatError;
+exports.LZMAMemoryError = LZMAMemoryError;
+exports.LZMAMemoryLimitError = LZMAMemoryLimitError;
+exports.LZMAOptionsError = LZMAOptionsError;
+exports.LZMAPool = LZMAPool;
+exports.LZMAProgrammingError = LZMAProgrammingError;
+exports.LZMAStatus = LZMAStatus;
+exports.LZMA_BUF_ERROR = LZMA_BUF_ERROR;
+exports.LZMA_DATA_ERROR = LZMA_DATA_ERROR;
+exports.LZMA_FILTERS_MAX = LZMA_FILTERS_MAX;
+exports.LZMA_FILTER_ARM = LZMA_FILTER_ARM;
+exports.LZMA_FILTER_ARMTHUMB = LZMA_FILTER_ARMTHUMB;
+exports.LZMA_FILTER_IA64 = LZMA_FILTER_IA64;
+exports.LZMA_FILTER_POWERPC = LZMA_FILTER_POWERPC;
+exports.LZMA_FILTER_X86 = LZMA_FILTER_X86;
+exports.LZMA_FINISH = LZMA_FINISH;
+exports.LZMA_FORMAT_ERROR = LZMA_FORMAT_ERROR;
+exports.LZMA_FULL_FLUSH = LZMA_FULL_FLUSH;
+exports.LZMA_GET_CHECK = LZMA_GET_CHECK;
+exports.LZMA_MEMLIMIT_ERROR = LZMA_MEMLIMIT_ERROR;
+exports.LZMA_MEM_ERROR = LZMA_MEM_ERROR;
+exports.LZMA_NO_CHECK = LZMA_NO_CHECK;
+exports.LZMA_OK = LZMA_OK;
+exports.LZMA_OPTIONS_ERROR = LZMA_OPTIONS_ERROR;
+exports.LZMA_PROG_ERROR = LZMA_PROG_ERROR;
+exports.LZMA_RUN = LZMA_RUN;
+exports.LZMA_STREAM_END = LZMA_STREAM_END;
+exports.LZMA_SYNC_FLUSH = LZMA_SYNC_FLUSH;
+exports.LZMA_UNSUPPORTED_CHECK = LZMA_UNSUPPORTED_CHECK;
+exports.Unxz = Unxz;
+exports.Xz = Xz;
+exports.XzStream = XzStream;
+exports.check = check;
+exports.createUnxz = createUnxz;
+exports.createXz = createXz;
+exports.default = lzma_default;
+exports.easyDecoderMemusage = easyDecoderMemusage;
+exports.easyEncoderMemusage = easyEncoderMemusage;
+exports.filter = filter;
+exports.flag = flag;
+exports.hasThreads = hasThreads;
+exports.isXZ = isXZ;
+exports.messages = messages;
+exports.mode = mode;
+exports.parseFileIndex = parseFileIndex;
+exports.preset = preset;
+exports.unxz = unxz;
+exports.unxzAsync = unxzAsync;
+exports.unxzFile = unxzFile;
+exports.unxzSync = unxzSync;
+exports.versionNumber = versionNumber;
+exports.versionString = versionString;
+exports.xz = xz;
+exports.xzAsync = xzAsync;
+exports.xzFile = xzFile;
+exports.xzSync = xzSync;
+
+//# sourceMappingURL=lzma-xM_ySpEU.cjs.map