node-liblzma 1.1.4 → 1.1.5

package/package.json

@@ -1,20 +1,18 @@
 {
   "name": "node-liblzma",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "NodeJS wrapper for liblzma",
   "main": "./lib/lzma.js",
   "scripts": {
     "install": "node-gyp install",
-    "postinstall": "run-p build:*",
-    "build:native": "node-gyp rebuild",
-    "build:coffee": "coffee --compile --output lib/ src/",
+    "postinstall": "node-gyp rebuild",
+    "prepublish": "coffee --compile --output lib/ src/",
     "rebuild": "node-gyp rebuild",
     "test": "npx mocha test/*.coffee"
   },
   "dependencies": {
     "node-addon-api": "4.2.0",
-    "node-gyp-build": "4.3.0",
-    "npm-run-all": "4.1.5"
+    "node-gyp-build": "4.3.0"
   },
   "devDependencies": {
     "coffeescript": "2.6.1",

package/src/bindings/module.cpp

@@ -1,107 +0,0 @@
-/**
-	* 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, "STREAM_ENCODE_MT"), Napi::Number::New(env, STREAM_ENCODE_MT));
-
-	exports.Set(Napi::String::New(env, "BUFSIZ"), Napi::Number::New(env, BUFSIZ));
-
-	return exports;
-}
-
-NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

package/src/bindings/node-liblzma.cpp

@@ -1,339 +0,0 @@
-/**
-	* 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: {
-			ret = lzma_stream_encoder(&this->_stream, filters, check);
-			break;
-		}
-
-		case STREAM_ENCODE_MT: {
-			Napi::Value optsThreads = opts.Get("threads");
-			if (!optsThreads.IsNumber()) {
-				Napi::Error::New(env, "Threads must be an integer");
-				return;
-			}
-
-			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
-
-		ret = lzma_stream_encoder_mt(&this->_stream, &mt);
-		break;
-	}
-// #endif
-	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

@@ -1,87 +0,0 @@
-/**
-	* 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;
-constexpr unsigned int STREAM_ENCODE_MT = 2;
-
-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

@@ -1,346 +0,0 @@
-###
- * 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.STREAM_ENCODE_MT
-
-      # By default set to maximum available processors
-      if @_opts.threads is 0
-        @_opts.threads = maxThreads
-
-      mode = liblzma.STREAM_ENCODE_MT if @_opts.threads > 1
-
-    # 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 = ->
-  typeof liblzma.STREAM_ENCODE_MT != 'undefined'
-
-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