node-liblzma 1.1.8 → 1.1.9

package/History.md

@@ -1,8 +1,10 @@
+# 1.1.9
+* Fix building if no prebuilt binary found
+
 # 1.1.7
 * Fix build system
 * Fix release system
 * Fix documentation
-* Fix building if no prebuilt binary found
 
 # 1.1.0
 * Refactor to deprecate Nan in favor of N-API

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-liblzma",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "NodeJS wrapper for liblzma",
   "main": "./lib/lzma.js",
   "scripts": {

package/src/bindings/module.cpp

@@ -0,0 +1,107 @@
+/**
+	* node-liblzma - Node.js bindings for liblzma
+	* Copyright (C) 2014-2015 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/>.
+**/
+
+#include "node-liblzma.hpp"
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+	LZMA::Init(env, exports);
+
+	// Constants
+	// enum lzma_ret
+	exports.Set(Napi::String::New(env, "LZMA_OK"), Napi::Number::New(env, LZMA_OK));
+	exports.Set(Napi::String::New(env, "LZMA_STREAM_END"), Napi::Number::New(env, LZMA_STREAM_END));
+	exports.Set(Napi::String::New(env, "LZMA_NO_CHECK"), Napi::Number::New(env, LZMA_NO_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_UNSUPPORTED_CHECK"), Napi::Number::New(env, LZMA_UNSUPPORTED_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_GET_CHECK"), Napi::Number::New(env, LZMA_GET_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_MEM_ERROR"), Napi::Number::New(env, LZMA_MEM_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_MEMLIMIT_ERROR"), Napi::Number::New(env, LZMA_MEMLIMIT_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_FORMAT_ERROR"), Napi::Number::New(env, LZMA_FORMAT_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_OPTIONS_ERROR"), Napi::Number::New(env, LZMA_OPTIONS_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_DATA_ERROR"), Napi::Number::New(env, LZMA_DATA_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_BUF_ERROR"), Napi::Number::New(env, LZMA_BUF_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_PROG_ERROR"), Napi::Number::New(env, LZMA_PROG_ERROR));
+
+	// enum lzma_action
+	exports.Set(Napi::String::New(env, "LZMA_RUN"), Napi::Number::New(env, LZMA_RUN));
+	exports.Set(Napi::String::New(env, "LZMA_SYNC_FLUSH"), Napi::Number::New(env, LZMA_SYNC_FLUSH));
+	exports.Set(Napi::String::New(env, "LZMA_FULL_FLUSH"), Napi::Number::New(env, LZMA_FULL_FLUSH));
+	exports.Set(Napi::String::New(env, "LZMA_FINISH"), Napi::Number::New(env, LZMA_FINISH));
+
+	// enum lzma_check
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_NONE"), Napi::Number::New(env, LZMA_CHECK_NONE));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_CRC32"), Napi::Number::New(env, LZMA_CHECK_CRC32));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_CRC64"), Napi::Number::New(env, LZMA_CHECK_CRC64));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_SHA256"), Napi::Number::New(env, LZMA_CHECK_SHA256));
+
+	// lzma_match_finder
+	exports.Set(Napi::String::New(env, "MF_HC3"), Napi::Number::New(env, LZMA_MF_HC3));
+	exports.Set(Napi::String::New(env, "MF_HC4"), Napi::Number::New(env, LZMA_MF_HC4));
+	exports.Set(Napi::String::New(env, "MF_BT2"), Napi::Number::New(env, LZMA_MF_BT2));
+	exports.Set(Napi::String::New(env, "MF_BT3"), Napi::Number::New(env, LZMA_MF_BT3));
+	exports.Set(Napi::String::New(env, "MF_BT4"), Napi::Number::New(env, LZMA_MF_BT4));
+
+	// lzma_mode
+	exports.Set(Napi::String::New(env, "LZMA_MODE_FAST"), Napi::Number::New(env, LZMA_MODE_FAST));
+	exports.Set(Napi::String::New(env, "LZMA_MODE_NORMAL"), Napi::Number::New(env, LZMA_MODE_NORMAL));
+
+	// defines
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_X86"), Napi::Number::New(env, LZMA_FILTER_X86));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_POWERPC"), Napi::Number::New(env, LZMA_FILTER_POWERPC));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_IA64"), Napi::Number::New(env, LZMA_FILTER_IA64));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_ARM"), Napi::Number::New(env, LZMA_FILTER_ARM));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_ARMTHUMB"), Napi::Number::New(env, LZMA_FILTER_ARMTHUMB));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_SPARC"), Napi::Number::New(env, LZMA_FILTER_SPARC));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_DELTA"), Napi::Number::New(env, LZMA_FILTER_DELTA));
+	exports.Set(Napi::String::New(env, "LZMA_FILTERS_MAX"), Napi::Number::New(env, LZMA_FILTERS_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_LZMA1"), Napi::Number::New(env, LZMA_FILTER_LZMA1));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_LZMA2"), Napi::Number::New(env, LZMA_FILTER_LZMA2));
+	exports.Set(Napi::String::New(env, "LZMA_VLI_UNKNOWN"), Napi::Number::New(env, LZMA_VLI_UNKNOWN));
+
+	exports.Set(Napi::String::New(env, "LZMA_VLI_BYTES_MAX"), Napi::Number::New(env, LZMA_VLI_BYTES_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_ID_MAX"), Napi::Number::New(env, LZMA_CHECK_ID_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_SIZE_MAX"), Napi::Number::New(env, LZMA_CHECK_SIZE_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_PRESET_DEFAULT"), Napi::Number::New(env, LZMA_PRESET_DEFAULT));
+	exports.Set(Napi::String::New(env, "LZMA_PRESET_LEVEL_MASK"), Napi::Number::New(env, LZMA_PRESET_LEVEL_MASK));
+	exports.Set(Napi::String::New(env, "LZMA_PRESET_EXTREME"), Napi::Number::New(env, LZMA_PRESET_EXTREME));
+	exports.Set(Napi::String::New(env, "LZMA_TELL_NO_CHECK"), Napi::Number::New(env, LZMA_TELL_NO_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_TELL_UNSUPPORTED_CHECK"), Napi::Number::New(env, LZMA_TELL_UNSUPPORTED_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_TELL_ANY_CHECK"), Napi::Number::New(env, LZMA_TELL_ANY_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_CONCATENATED"), Napi::Number::New(env, LZMA_CONCATENATED));
+	exports.Set(Napi::String::New(env, "LZMA_STREAM_HEADER_SIZE"), Napi::Number::New(env, LZMA_STREAM_HEADER_SIZE));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_MAJOR"), Napi::Number::New(env, LZMA_VERSION_MAJOR));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_MINOR"), Napi::Number::New(env, LZMA_VERSION_MINOR));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_PATCH"), Napi::Number::New(env, LZMA_VERSION_PATCH));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY"), Napi::Number::New(env, LZMA_VERSION_STABILITY));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY_ALPHA"), Napi::Number::New(env, LZMA_VERSION_STABILITY_ALPHA));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY_BETA"), Napi::Number::New(env, LZMA_VERSION_STABILITY_BETA));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY_STABLE"), Napi::Number::New(env, LZMA_VERSION_STABILITY_STABLE));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION"), Napi::Number::New(env, LZMA_VERSION));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STRING"), Napi::String::New(env, LZMA_VERSION_STRING));
+
+	// LZMAStream flags
+	exports.Set(Napi::String::New(env, "STREAM_ENCODE"), Napi::Number::New(env, STREAM_ENCODE));
+	exports.Set(Napi::String::New(env, "STREAM_DECODE"), Napi::Number::New(env, STREAM_DECODE));
+	exports.Set(Napi::String::New(env, "BUFSIZ"), Napi::Number::New(env, BUFSIZ));
+
+	// Tell companion script if we are thread-able or not
+	exports.Set(Napi::String::New(env, "HAS_THREADS_SUPPORT"), Napi::Boolean::New(env, HAS_THREADS_SUPPORT));
+	return exports;
+}
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

package/src/bindings/node-liblzma.cpp

@@ -0,0 +1,340 @@
+/**
+	* 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/>.
+	**/
+
+#include "node-liblzma.hpp"
+#include <node_buffer.h>
+
+Napi::Value LZMA::Close(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	return LZMA::Close(env);
+}
+
+Napi::Value LZMA::Close(const Napi::Env &env) {
+	Napi::MemoryManagement::AdjustExternalMemory(env, -int64_t(sizeof(LZMA)));
+
+	if(_wip) {
+		_pending_close = true;
+		return env.Undefined();
+	}
+
+	_pending_close = false;
+
+	lzma_end(&_stream);
+
+	return env.Undefined();
+}
+
+void LZMA::Init(Napi::Env env, Napi::Object exports) {
+	Napi::Function func =
+		DefineClass(env,
+			"LZMA",
+			{
+				InstanceMethod("code", &LZMA::Code<true>),
+				InstanceMethod("codeSync", &LZMA::Code<false>),
+				InstanceMethod("close", &LZMA::Close)
+			});
+
+	Napi::FunctionReference* constructor = new Napi::FunctionReference();
+	*constructor = Napi::Persistent(func);
+	env.SetInstanceData(constructor);
+
+	exports.Set("LZMA", func);
+}
+
+LZMA::LZMA(const Napi::CallbackInfo& info) : Napi::ObjectWrap<LZMA>(info), _stream(LZMA_STREAM_INIT),
+	_wip(false), _pending_close(false), _worker(nullptr)
+{
+	Napi::Env env = info.Env();
+
+	if( info.Length() != 2 ) {
+		Napi::TypeError::New(env, "Wrong number of arguments, expected mode(int) and opts(object)").ThrowAsJavaScriptException();
+		return;
+	}
+
+	uint32_t mode = info[0].ToNumber().Uint32Value();
+
+	if (!info[1].IsObject()) {
+		Napi::TypeError::New(env, "Expected object as second argument").ThrowAsJavaScriptException();
+		return;
+	}
+
+	Napi::Object opts = info[1].ToObject();
+
+	Napi::Value optsCheck = opts.Get("check");
+	if (!optsCheck.IsNumber()) {
+		Napi::TypeError::New(env, "Expected 'check' to be an integer").ThrowAsJavaScriptException();
+		return;
+	}
+
+	lzma_check check = static_cast<lzma_check>(optsCheck.ToNumber().Uint32Value());
+
+	Napi::Value optsPreset = opts.Get("preset");
+	if (!optsPreset.IsNumber()) {
+		Napi::TypeError::New(env, "Expected 'preset' to be an integer").ThrowAsJavaScriptException();
+		return;
+	}
+
+	uint32_t preset = optsPreset.ToNumber().Uint32Value();
+
+	Napi::Value optsFilters = opts.Get("filters");
+	if (!optsFilters.IsArray()) {
+		Napi::TypeError::New(env, "Expected 'filters' to be an array").ThrowAsJavaScriptException();
+		return;
+	}
+
+	Napi::Array filters_handle = optsFilters.As<Napi::Array>();
+
+	uint32_t filters_len = filters_handle.Length();
+
+	// We will need to add LZMA_VLI_UNKNOWN after, so user defined filters may
+	// not exceed LZMA_FILTERS_MAX - 1.
+	if( filters_len > LZMA_FILTERS_MAX - 1) {
+		Napi::RangeError::New(env, "More filters than allowed maximum").ThrowAsJavaScriptException();
+		return;
+	}
+
+	lzma_options_lzma opt_lzma2;
+	if( lzma_lzma_preset(&opt_lzma2, preset) ) {
+		Napi::Error::New(env, "Unsupported preset, possibly a bug").ThrowAsJavaScriptException();
+		return;
+	}
+
+	// Add extra slot for LZMA_VLI_UNKNOWN.
+	this->filters = new lzma_filter[filters_len + 1];
+
+	for(uint32_t i = 0; i < filters_len; ++i) {
+		Napi::Value filter = filters_handle.Get(i);
+		if (!filter.IsNumber()) {
+			Napi::Error::New(env, "Filter must be an integer").ThrowAsJavaScriptException();
+			return;
+		}
+
+		uint64_t current = filter.ToNumber().Uint32Value();
+		filters[i].id = current;
+		if( current == LZMA_FILTER_LZMA2 ) {
+			filters[i].options = &opt_lzma2;
+		} else {
+			filters[i].options = nullptr;
+		}
+	}
+
+	filters[filters_len] = { .id = LZMA_VLI_UNKNOWN, .options = nullptr };
+
+	lzma_ret ret;
+	switch(mode) {
+		case STREAM_DECODE: {
+			ret = lzma_stream_decoder(&this->_stream, UINT64_MAX, check);
+			break;
+		}
+		case STREAM_ENCODE: {
+			Napi::Value optsThreads = opts.Get("threads");
+			if (!optsThreads.IsNumber()) {
+				Napi::Error::New(env, "Threads must be an integer");
+				return;
+			}
+
+#ifdef ENABLE_THREAD_SUPPORT
+			unsigned int threads = optsThreads.ToNumber().Uint32Value();
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+
+			lzma_mt mt = {
+				.flags = 0,
+				.threads = threads,
+				.block_size = 0,
+				.timeout = 0,
+				.preset = preset,
+				.filters = filters,
+				.check = check,
+			};
+
+#pragma GCC diagnostic pop
+
+			if( threads > 1 ) {
+				ret = lzma_stream_encoder_mt(&this->_stream, &mt);
+			} else {
+				ret = lzma_stream_encoder(&this->_stream, filters, check);
+			}
+#else
+			ret = lzma_stream_encoder(&this->_stream, filters, check);
+#endif
+		break;
+	}
+	default:
+		ret = LZMA_OPTIONS_ERROR;
+	}
+
+	if (ret != LZMA_OK) {
+		Napi::Error::New(env, "LZMA failure, returned " + std::to_string(ret));
+		return;
+	}
+
+	Napi::MemoryManagement::AdjustExternalMemory(env, sizeof(LZMA));
+}
+
+/**<
+	* \brief Do the encoding/decoding with async support
+	*
+	* Function prototype is (sync):
+	* .codeSync flushFlag, input_buffer, input_offset, output_buffer, output_offset, callback
+	* Function prototype is (async):
+	* .code flushFlag, input_buffer, input_offset, availInBefore, output_buffer, output_offset, callback
+	*
+	* Where:
+	* flushFlag: type: Uint32
+	* input_buffer: type: Buffer
+	* input_offset: type: Uint32
+	* availInBefore: type: Uint32
+	* output_buffer: type: Buffer
+	* output_offset: type: Uint32
+	* callback: type: Function
+	*/
+template<bool async>
+Napi::Value LZMA::Code(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	this->_wip = true;
+	this->Ref();
+
+	// Neat trick but that does the job :)
+	if (info.Length() != 6+(int)async) {
+		Napi::Error::New(env, "BUG?: LZMA::Code requires all these arguments: "
+			"flushFlag, input_buffer, input_offset, availInBefore, "
+			"output_buffer, output_offset, [callback]").ThrowAsJavaScriptException();
+		return env.Undefined();
+	}
+
+	if (!info[0].IsNumber()) {
+		Napi::Error::New(env, "flushFlag must be an integer");
+		return env.Undefined();
+	}
+	this->_action = static_cast<lzma_action>(info[0].ToNumber().Uint32Value());
+
+	// Evaluate parameters passed to us
+	const uint8_t *in;
+	uint8_t *out;
+	size_t in_off, in_len, out_off, out_len;
+
+		// If we do not have input buffer data
+	if (info[1].IsNull()) {
+		// just a flush
+		// uint8_t nada[1] = { 0 };
+		uint8_t nada = 0;
+		in = &nada;
+		in_len = 0;
+		in_off = 0;
+	} else {
+		// if (!node::Buffer::HasInstance(info[1])) {
+		if (!info[1].IsBuffer()) {
+			Napi::TypeError::New(env, "BUG?: LZMA::Code 'input_buffer' argument must be a Buffer").ThrowAsJavaScriptException();
+			return env.Undefined();
+		}
+
+		uint8_t *in_buf = info[1].As<Napi::Buffer<uint8_t>>().Data();
+		in_off = info[2].ToNumber().Uint32Value();
+		in_len = info[3].ToNumber().Uint32Value();
+		size_t in_max = info[1].As<Napi::Buffer<uint8_t>>().Length();
+
+		if(!node::Buffer::IsWithinBounds(in_off, in_len, in_max)) {
+			Napi::Error::New(env, "Offset out of bounds!").ThrowAsJavaScriptException();
+			return env.Undefined();
+		}
+		in = in_buf + in_off;
+	}
+
+		// Check if output buffer is also a Buffer
+	if( !info[4].IsBuffer() ) {
+		Napi::TypeError::New(env, "BUG?: LZMA::Code 'output_buffer' argument must be a Buffer").ThrowAsJavaScriptException();
+		return env.Undefined();
+	}
+
+	uint8_t *out_buf = info[4].As<Napi::Buffer<uint8_t>>().Data();
+	out_off = info[5].ToNumber().Uint32Value();
+	out_len = info[4].As<Napi::Buffer<uint8_t>>().Length() - out_off;
+	out = out_buf + out_off;
+
+	// Only if async mode is enabled shall we need a callback function
+	if(async) {
+		this->_callback = Napi::Persistent(info[6].As<Napi::Function>());
+	}
+
+	this->_stream.next_in = in;
+	this->_stream.avail_in = in_len;
+	this->_stream.next_out = out;
+	this->_stream.avail_out = out_len;
+
+	// do it synchronously
+	if(async) {
+		this->_worker = new LZMAWorker(env, this);
+		this->_worker->Queue();
+	} else {
+		Process(this);
+		return AfterSync(info, this);
+	}
+
+	// otherwise queue work, make sure we get our work done by first calling Process and then After
+	// napi_create_async_work(uv_default_loop(), &(this->_req), LZMA::Process, LZMA::After);
+	return env.Undefined();
+}
+
+void LZMA::Process(LZMA* obj) {
+	// the real work is done here :)
+	obj->_wip = true;
+	obj->_ret = lzma_code(&(obj->_stream), obj->_action);
+}
+
+void LZMA::After(Napi::Env env, LZMA* obj /*, int status */) {
+
+	Napi::Number ret_code = Napi::Number::New(env, obj->_ret);
+	Napi::Number avail_in = Napi::Number::New(env, obj->_stream.avail_in);
+	Napi::Number avail_out = Napi::Number::New(env, obj->_stream.avail_out);
+
+	obj->_wip = false;
+
+	obj->_callback.Call({ ret_code, avail_in, avail_out });
+
+	obj->Unref();
+
+	if(obj->_pending_close) {
+		obj->Close(env);
+	}
+}
+
+Napi::Value LZMA::AfterSync(const Napi::CallbackInfo &info, LZMA* obj) {
+	Napi::Env env = info.Env();
+
+	Napi::Number ret_code = Napi::Number::New(env, obj->_ret);
+	Napi::Number avail_in = Napi::Number::New(env, obj->_stream.avail_in);
+	Napi::Number avail_out = Napi::Number::New(env, obj->_stream.avail_out);
+	Napi::Array result = Napi::Array::New(env, 3);
+
+	uint32_t i = 0;
+		result[i++] = ret_code;
+		result[i++] = avail_in;
+		result[i++] = avail_out;
+
+		obj->_wip = false;
+
+		obj->Unref();
+		if(obj->_pending_close) {
+			obj->Close(info);
+		}
+
+		return result;
+}

package/src/bindings/node-liblzma.hpp

@@ -0,0 +1,91 @@
+/**
+	* node-liblzma - Node.js bindings for liblzma
+	* Copyright (C) 2014-2015 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/>.
+	**/
+
+#ifndef BUILDING_NODE_EXTENSION
+#define BUILDING_NODE_EXTENSION
+#endif
+
+#ifndef NODE_LIBLZMA_H
+#define NODE_LIBLZMA_H
+
+#include <lzma.h>
+#include <napi.h>
+
+#include <sstream>
+
+constexpr unsigned int STREAM_ENCODE = 0;
+constexpr unsigned int STREAM_DECODE = 1;
+#ifdef ENABLE_THREAD_SUPPORT
+constexpr bool HAS_THREADS_SUPPORT = true;
+#else
+constexpr bool HAS_THREADS_SUPPORT = false;
+#endif
+
+class LZMAWorker;
+class LZMA : public Napi::ObjectWrap<LZMA> {
+public:
+	static void Init(Napi::Env env, Napi::Object exports);
+
+	explicit LZMA(const Napi::CallbackInfo& info);
+	~LZMA() = default;
+
+  Napi::Value Close(const Napi::CallbackInfo &info);
+  Napi::Value Close(const Napi::Env &env);
+
+	template<bool async>
+  Napi::Value Code(const Napi::CallbackInfo &info);
+
+	static void Process(LZMA* obj);
+	static void After(Napi::Env env, LZMA* obj /*, int status */);
+	static Napi::Value AfterSync(const Napi::CallbackInfo &info, LZMA* obj);
+
+private:
+	lzma_stream _stream;
+	bool _wip;
+	bool _pending_close;
+
+  LZMAWorker* _worker;
+
+	lzma_action _action;
+	Napi::FunctionReference _callback;
+	lzma_ret _ret;
+  lzma_filter *filters;
+};
+
+class LZMAWorker : public Napi::AsyncWorker {
+	public:
+		LZMAWorker(Napi::Env env, LZMA* instance) : AsyncWorker(env), lzma(instance) { }
+		~LZMAWorker() = default;
+
+		void Execute() {
+			LZMA::Process(this->lzma);
+		}
+		void OnOK() {
+			Napi::HandleScope scope(Env());
+			LZMA::After(Env(), this->lzma);
+		}
+		void OnError(const Napi::Error& e) {
+			Napi::HandleScope scope(Env());
+			LZMA::After(Env(), this->lzma);
+		}
+
+	private:
+		LZMA *lzma;
+};
+
+#endif // NODE_LIBLZMA_H

package/src/lzma.coffee

@@ -0,0 +1,344 @@
+###
+ * 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/>.
+###
+
+path = require 'path'
+binding_path = path.resolve path.join __dirname, '..'
+
+liblzma = require('node-gyp-build')(binding_path)
+util = require 'util'
+assert = require 'assert'
+os = require 'os'
+{ Transform } = require 'stream'
+
+# Should not change over time... :)
+maxThreads = os.cpus().length
+
+class XzStream extends Transform
+  constructor: (mode, @_opts = {}, options) ->
+    super options
+
+    @_opts.check ?= exports.check.NONE
+    @_opts.preset ?= exports.preset.DEFAULT
+    @_opts.filters ?= [exports.filter.LZMA2]
+    @_opts.mode ?= exports.mode.NORMAL
+    @_opts.threads ?= 1
+
+    @_chunkSize = if @_opts.chunkSize then @_opts.chunkSize else liblzma.BUFSIZ
+
+    # By default no flush, since there is no LZMA_NO_SYNC, we stick to
+    # default LZMA_RUN (0)
+    @_flushFlag = @_opts.flushFlag or liblzma.LZMA_RUN
+
+    assert Array.isArray(@_opts.filters), "Filters need to be in an array!"
+
+    # Add default filter LZMA2 if none provided
+    if @_opts.filters.indexOf(exports.filter.LZMA2) is -1
+      @_opts.filters.push exports.filter.LZMA2
+
+    # Multithreading is only available for encoding, so if we are encoding, check
+    # opts threads value.
+    if mode is liblzma.STREAM_ENCODE
+      @_opts.threads = 1 unless liblzma.HAS_THREADS_SUPPORT
+
+      # By default set to maximum available processors
+      if @_opts.threads is 0
+        @_opts.threads = maxThreads
+
+    # Initialize engine
+    @lzma = new liblzma.LZMA mode, @_opts
+    @_closed = false
+    @_hadError = false
+    @_offset = 0
+    @_buffer = Buffer.alloc @_chunkSize
+
+    @on 'onerror', (errno) =>
+      @_hadError = true
+      error = new Error exports.messages[errno]
+      error.errno = errno
+      error.code = errno
+
+      @emit 'error', error
+
+    @once 'end', @close
+
+  flush: (kind, callback) ->
+    ws = @_writableState
+
+    if (typeof kind == 'function' or (typeof kind == 'undefined' && !callback))
+      [callback, kind] = [kind, liblzma.LZMA_SYNC_FLUSH]
+
+    if ws.ended
+      if callback
+        process.nextTick callback
+    else if ws.ending
+      if callback
+        @once 'end', callback
+    else if ws.needDrain
+      @once 'drain', =>
+        @flush callback
+        return
+    else
+      @_flushFlag = kind
+      @write Buffer.alloc(0), '', callback
+
+    return
+
+  close: (callback) ->
+    if callback
+      process.nextTick callback
+
+    # We will trigger this case with #xz and #unxz
+    return if @_closed
+
+    @lzma.close()
+    @_closed = true
+
+    process.nextTick =>
+      @emit 'close'
+      return
+
+    return
+
+  _transform: (chunk, encoding, callback) ->
+    flushFlag = undefined
+    ws = @_writableState
+    ending = ws.ending or ws.ended
+    last = ending and (not chunk or ws.length is chunk.length)
+    return callback(new Error("invalid input")) if chunk != null and !(chunk instanceof Buffer)
+    return callback(new Error("lzma binding closed")) if @_closed
+
+    # If it's the last chunk, or a final flush, we use the LZMA_FINISH flush flag.
+    # If it's explicitly flushing at some other time, then we use
+    # LZMA_SYNC_FLUSH.
+    if last
+      flushFlag = liblzma.LZMA_FINISH
+    else
+      flushFlag = @_flushFlag
+
+      # once we've flushed the last of the queue, stop flushing and
+      # go back to the normal behavior.
+      @_flushFlag = @_opts.flushFlag or liblzma.LZMA_RUN if chunk.length >= ws.length
+
+    @_processChunk chunk, flushFlag, callback
+    return
+
+  _flush: (callback) ->
+    @_transform Buffer.alloc(0), '', callback
+    return
+
+  _processChunk: (chunk, flushFlag, cb) ->
+    # If user setting async is set to true, then it will all depend on whether
+    # we can actually be async, or not. If user set explicitly async to false
+    # then whether we have a callback or not becomes irrelevant..
+    # TODO: Works in v0.11
+    #async = util.isFunction cb
+    # until then...
+    async = typeof cb == 'function'
+
+    # Sanity checks
+    assert !@_closed, "Stream closed!"
+
+    availInBefore = chunk && chunk.length
+    availOutBefore = @_chunkSize - @_offset
+    inOff = 0
+
+    # So far it looks like Zlib _processChunk in CoffeeScript. But to make C++
+    # code easier when it comes to emitting events and callback calling sync/async
+    # we handle error codes here. If anything wrong is returned, we emit event
+    # and return false in case we are synchronous.
+    callback = (errno, availInAfter, availOutAfter) =>
+      return if @_hadError
+
+      # if LZMA engine returned something else, we are running into trouble!
+      if errno isnt liblzma.LZMA_OK and errno isnt liblzma.LZMA_STREAM_END
+        @emit 'onerror', errno
+        return false
+
+      used = availOutBefore - availOutAfter
+      assert used >= 0, "More bytes after than before! Delta = #{used}"
+
+      if used > 0
+        out = @_buffer[ @_offset ... @_offset + used ]
+        @_offset += used
+        if async
+          @push out
+        else
+          buffers.push out
+          nread += used
+
+      # exhausted the output buffer, or used all the input create a new one.
+      if availOutAfter is 0 or @_offset >= @_chunkSize
+        availOutBefore = @_chunkSize
+        @_offset = 0
+        @_buffer = Buffer.alloc @_chunkSize
+
+      if availOutAfter is 0 or availInAfter > 0
+        inOff += (availInBefore - availInAfter)
+        availInBefore = availInAfter
+
+        return true unless async
+        @lzma.code flushFlag, chunk, inOff, availInBefore, @_buffer, @_offset, callback
+        return
+
+      return false unless async
+      cb()
+      return
+
+    unless async
+      # Doing it synchronously
+      buffers = []
+      nread = 0
+
+      error = null
+      @on 'error', (e) -> error = e
+
+      loop
+        res = @lzma.codeSync flushFlag, chunk, inOff, availInBefore, @_buffer, @_offset
+        break unless not @_hadError and callback res[0], res[1], res[2]
+
+      throw error if @_hadError
+      @close()
+
+      buf = Buffer.concat buffers, nread
+      return buf
+
+    @lzma.code flushFlag, chunk, inOff, availInBefore, @_buffer, @_offset, callback
+
+    return
+
+class Xz extends XzStream
+  constructor: (lzma_options, options) ->
+    super liblzma.STREAM_ENCODE, lzma_options, options
+
+class Unxz extends XzStream
+  constructor: (lzma_options, options) ->
+    super liblzma.STREAM_DECODE, lzma_options, options
+
+
+exports.Xz = Xz
+exports.Unxz = Unxz
+
+exports.hasThreads = ->
+  liblzma.HAS_THREADS_SUPPORT
+
+exports.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"
+]
+
+exports.check = {
+  "NONE": liblzma.LZMA_CHECK_NONE
+  "CRC32": liblzma.LZMA_CHECK_CRC32
+  "CRC64": liblzma.LZMA_CHECK_CRC64
+  "SHA256": liblzma.LZMA_CHECK_SHA256
+}
+
+exports.preset = {
+  "DEFAULT": liblzma.LZMA_PRESET_DEFAULT
+  "EXTREME": liblzma.LZMA_PRESET_EXTREME
+}
+
+exports.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
+}
+
+exports.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
+}
+
+exports.mode = {
+  "FAST": liblzma.LZMA_MODE_FAST
+  "NORMAL": liblzma.LZMA_MODE_NORMAL
+}
+
+exports.createXz = (lzma_options, options) ->
+  new Xz(lzma_options, options)
+
+exports.createUnxz = (lzma_options, options) ->
+  new Unxz(lzma_options, options)
+
+exports.unxz = (buffer, opts, callback) ->
+  if typeof opts == 'function'
+    [callback, opts] = [opts, {}]
+
+  xzBuffer new Unxz(opts), buffer, callback
+
+exports.unxzSync = (buffer, opts) ->
+  xzBufferSync new Unxz(opts), buffer
+
+exports.xz = (buffer, opts, callback) ->
+  if typeof opts == 'function'
+    [callback, opts] = [opts, {}]
+  xzBuffer new Xz(opts), buffer, callback
+
+exports.xzSync = (buffer, opts) ->
+  xzBufferSync new Xz(opts), buffer
+
+xzBuffer = (engine, buffer, callback) ->
+  buffers = []
+  nread = 0
+  flow = ->
+    chunk = undefined
+    while null isnt (chunk = engine.read())
+      buffers.push chunk
+      nread += chunk.length
+    engine.once 'readable', flow
+    return
+  onEnd = ->
+    buf = Buffer.concat(buffers, nread)
+    buffers = []
+    callback null, buf
+    engine.close()
+    return
+  onError = (err) ->
+    engine.removeListener 'end', onEnd
+    engine.removeListener 'readable', flow
+    callback err
+    return
+  engine.on 'error', onError
+  engine.on 'end', onEnd
+  engine.end buffer
+  flow()
+  return
+
+xzBufferSync = (engine, buffer) ->
+  buffer = Buffer.from(buffer) if typeof buffer == 'string'
+  throw new TypeError("Not a string or buffer") unless buffer instanceof Buffer
+
+  engine._processChunk buffer, liblzma.LZMA_FINISH
+
+module.exports = exports