node-liblzma 1.0.4-9 → 1.1.5

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"
-
-using namespace v8;
-
-void moduleInit(Local<Object> exports) {
-	LZMA::Init(exports);
-
-	// enum lzma_ret
-	exports->Set(NewString("LZMA_OK"),                Nan::New<Number>(LZMA_OK));
-	exports->Set(NewString("LZMA_STREAM_END"),        Nan::New<Number>(LZMA_STREAM_END));
-	exports->Set(NewString("LZMA_NO_CHECK"),          Nan::New<Number>(LZMA_NO_CHECK));
-	exports->Set(NewString("LZMA_UNSUPPORTED_CHECK"), Nan::New<Number>(LZMA_UNSUPPORTED_CHECK));
-	exports->Set(NewString("LZMA_GET_CHECK"),         Nan::New<Number>(LZMA_GET_CHECK));
-	exports->Set(NewString("LZMA_MEM_ERROR"),         Nan::New<Number>(LZMA_MEM_ERROR));
-	exports->Set(NewString("LZMA_MEMLIMIT_ERROR"),    Nan::New<Number>(LZMA_MEMLIMIT_ERROR));
-	exports->Set(NewString("LZMA_FORMAT_ERROR"),      Nan::New<Number>(LZMA_FORMAT_ERROR));
-	exports->Set(NewString("LZMA_OPTIONS_ERROR"),     Nan::New<Number>(LZMA_OPTIONS_ERROR));
-	exports->Set(NewString("LZMA_DATA_ERROR"),        Nan::New<Number>(LZMA_DATA_ERROR));
-	exports->Set(NewString("LZMA_BUF_ERROR"),         Nan::New<Number>(LZMA_BUF_ERROR));
-	exports->Set(NewString("LZMA_PROG_ERROR"),        Nan::New<Number>(LZMA_PROG_ERROR));
-
-	// enum lzma_action
-	exports->Set(NewString("LZMA_RUN"),        Nan::New<Number>(LZMA_RUN));
-	exports->Set(NewString("LZMA_SYNC_FLUSH"), Nan::New<Number>(LZMA_SYNC_FLUSH));
-	exports->Set(NewString("LZMA_FULL_FLUSH"), Nan::New<Number>(LZMA_FULL_FLUSH));
-	exports->Set(NewString("LZMA_FINISH"),     Nan::New<Number>(LZMA_FINISH));
-
-	// enum lzma_check
-	exports->Set(NewString("LZMA_CHECK_NONE"),   Nan::New<Number>(LZMA_CHECK_NONE));
-	exports->Set(NewString("LZMA_CHECK_CRC32"),  Nan::New<Number>(LZMA_CHECK_CRC32));
-	exports->Set(NewString("LZMA_CHECK_CRC64"),  Nan::New<Number>(LZMA_CHECK_CRC64));
-	exports->Set(NewString("LZMA_CHECK_SHA256"), Nan::New<Number>(LZMA_CHECK_SHA256));
-
-	// lzma_match_finder
-	exports->Set(NewString("MF_HC3"), Nan::New<Number>(LZMA_MF_HC3));
-	exports->Set(NewString("MF_HC4"), Nan::New<Number>(LZMA_MF_HC4));
-	exports->Set(NewString("MF_BT2"), Nan::New<Number>(LZMA_MF_BT2));
-	exports->Set(NewString("MF_BT3"), Nan::New<Number>(LZMA_MF_BT3));
-	exports->Set(NewString("MF_BT4"), Nan::New<Number>(LZMA_MF_BT4));
-
-	// lzma_mode
-	exports->Set(NewString("LZMA_MODE_FAST"),   Nan::New<Number>(LZMA_MODE_FAST));
-	exports->Set(NewString("LZMA_MODE_NORMAL"), Nan::New<Number>(LZMA_MODE_NORMAL));
-
-	// defines
-	exports->Set(NewString("LZMA_FILTER_X86"),          Nan::New<Number>(LZMA_FILTER_X86));
-	exports->Set(NewString("LZMA_FILTER_POWERPC"),      Nan::New<Number>(LZMA_FILTER_POWERPC));
-	exports->Set(NewString("LZMA_FILTER_IA64"),         Nan::New<Number>(LZMA_FILTER_IA64));
-	exports->Set(NewString("LZMA_FILTER_ARM"),          Nan::New<Number>(LZMA_FILTER_ARM));
-	exports->Set(NewString("LZMA_FILTER_ARMTHUMB"),     Nan::New<Number>(LZMA_FILTER_ARMTHUMB));
-	exports->Set(NewString("LZMA_FILTER_SPARC"),        Nan::New<Number>(LZMA_FILTER_SPARC));
-	exports->Set(NewString("LZMA_FILTER_DELTA"),        Nan::New<Number>(LZMA_FILTER_DELTA));
-	exports->Set(NewString("LZMA_FILTERS_MAX"),         Nan::New<Number>(LZMA_FILTERS_MAX));
-	exports->Set(NewString("LZMA_FILTER_LZMA1"),        Nan::New<Number>(LZMA_FILTER_LZMA1));
-	exports->Set(NewString("LZMA_FILTER_LZMA2"),        Nan::New<Number>(LZMA_FILTER_LZMA2));
-	exports->Set(NewString("LZMA_VLI_UNKNOWN"),         Nan::New<Number>(LZMA_VLI_UNKNOWN));
-
-	exports->Set(NewString("LZMA_VLI_BYTES_MAX"),            Nan::New<Number>(LZMA_VLI_BYTES_MAX));
-	exports->Set(NewString("LZMA_CHECK_ID_MAX"),             Nan::New<Number>(LZMA_CHECK_ID_MAX));
-	exports->Set(NewString("LZMA_CHECK_SIZE_MAX"),           Nan::New<Number>(LZMA_CHECK_SIZE_MAX));
-	exports->Set(NewString("LZMA_PRESET_DEFAULT"),           Nan::New<Number>(LZMA_PRESET_DEFAULT));
-	exports->Set(NewString("LZMA_PRESET_LEVEL_MASK"),        Nan::New<Number>(LZMA_PRESET_LEVEL_MASK));
-	exports->Set(NewString("LZMA_PRESET_EXTREME"),           Nan::New<Number>(LZMA_PRESET_EXTREME));
-	exports->Set(NewString("LZMA_TELL_NO_CHECK"),            Nan::New<Number>(LZMA_TELL_NO_CHECK));
-	exports->Set(NewString("LZMA_TELL_UNSUPPORTED_CHECK"),   Nan::New<Number>(LZMA_TELL_UNSUPPORTED_CHECK));
-	exports->Set(NewString("LZMA_TELL_ANY_CHECK"),           Nan::New<Number>(LZMA_TELL_ANY_CHECK));
-	exports->Set(NewString("LZMA_CONCATENATED"),             Nan::New<Number>(LZMA_CONCATENATED));
-	exports->Set(NewString("LZMA_STREAM_HEADER_SIZE"),       Nan::New<Number>(LZMA_STREAM_HEADER_SIZE));
-	exports->Set(NewString("LZMA_VERSION_MAJOR"),            Nan::New<Number>(LZMA_VERSION_MAJOR));
-	exports->Set(NewString("LZMA_VERSION_MINOR"),            Nan::New<Number>(LZMA_VERSION_MINOR));
-	exports->Set(NewString("LZMA_VERSION_PATCH"),            Nan::New<Number>(LZMA_VERSION_PATCH));
-	exports->Set(NewString("LZMA_VERSION_STABILITY"),        Nan::New<Number>(LZMA_VERSION_STABILITY));
-	exports->Set(NewString("LZMA_VERSION_STABILITY_ALPHA"),  Nan::New<Number>(LZMA_VERSION_STABILITY_ALPHA));
-	exports->Set(NewString("LZMA_VERSION_STABILITY_BETA"),   Nan::New<Number>(LZMA_VERSION_STABILITY_BETA));
-	exports->Set(NewString("LZMA_VERSION_STABILITY_STABLE"), Nan::New<Number>(LZMA_VERSION_STABILITY_STABLE));
-	exports->Set(NewString("LZMA_VERSION"),                  Nan::New<Number>(LZMA_VERSION));
-	exports->Set(NewString("LZMA_VERSION_STRING"),           NewString(LZMA_VERSION_STRING));
-
-  // LZMAStream flags
-  exports->Set(NewString("STREAM_ENCODE"),                  Nan::New<Number>(STREAM_ENCODE));
-  exports->Set(NewString("STREAM_DECODE"),                  Nan::New<Number>(STREAM_DECODE));
-#ifdef LIBLZMA_ENABLE_MT
-  exports->Set(NewString("STREAM_ENCODE_MT"),                  Nan::New<Number>(STREAM_ENCODE_MT));
-#endif
-
-  exports->Set(NewString("BUFSIZ"),                  Nan::New<Number>(BUFSIZ));
-}
-
-NODE_MODULE(node_liblzma, moduleInit)

package/src/bindings/node-liblzma.cpp

@@ -1,320 +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"
-#include <node_buffer.h>
-
-using namespace v8;
-
-Nan::Persistent<Function> LZMA::constructor;
-
-#define LZMA_FETCH_SELF() \
-	LZMA* self = NULL; \
-	if (!info.This().IsEmpty() && info.This()->InternalFieldCount() > 0) { \
-		self = Nan::ObjectWrap::Unwrap<LZMA>(info.This()); \
-	} \
-	if (!self) { \
-		_failMissingSelf(info); \
-		return; \
-	}
-
-void LZMA::Close() {
-  if(_wip) {
-    _pending_close = true;
-    return;
-  }
-
-  _pending_close = false;
-
-  lzma_end(&_stream);
-}
-
-void LZMA::Init(Local<Object> exports) {
-  // constructor template
-  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NewString("LZMA"));
-
-  // prototype methods
-  t->PrototypeTemplate()->Set(NewString("close"), Nan::New<FunctionTemplate>(Close));
-  t->PrototypeTemplate()->Set(NewString("code"), Nan::New<FunctionTemplate>(Code<true>));
-  t->PrototypeTemplate()->Set(NewString("codeSync"), Nan::New<FunctionTemplate>(Code<false>));
-
-	constructor.Reset(t->GetFunction());
-	exports->Set(NewString("LZMA"), Nan::New<Function>(constructor));
-}
-
-NAN_METHOD(LZMA::New) {
-	Nan::HandleScope scope;
-  if (!info.IsConstructCall()) {
-    // Invoked as plain function, turn into construct call.
-    info.GetReturnValue().Set(Nan::New<Function>(constructor)->NewInstance(0, NULL));
-  }
-
-  if( info.Length() != 2 ) {
-    Nan::ThrowTypeError(NewString("Wrong number of arguments, expected mode(int) and opts(object)"));
-    info.GetReturnValue().SetUndefined();
-		return;
-  }
-
-  uint32_t mode = info[0]->Uint32Value();
-
-  if (!info[1]->IsObject()) {
-    Nan::ThrowTypeError(NewString("Expected object as second argument"));
-    info.GetReturnValue().SetUndefined();
-		return;
-  }
-
-  Local<Object> opts = info[1]->ToObject();
-  lzma_check check = static_cast<lzma_check>(opts->Get(NewString("check"))->Uint32Value());
-  uint32_t preset = opts->Get(NewString("preset"))->Uint32Value();
-  Local<Array> filters_handle = Local<Array>::Cast(opts->Get(NewString("filters")));
-
-  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) {
-    Nan::ThrowRangeError(NewString("More filters than allowed maximum"));
-    info.GetReturnValue().SetUndefined();
-		return;
-  }
-
-  lzma_options_lzma opt_lzma2;
-  if( lzma_lzma_preset(&opt_lzma2, preset) ) {
-    Nan::ThrowError(NewString("Unsupported preset, possibly a bug"));
-    info.GetReturnValue().SetUndefined();
-		return;
-  }
-
-  // Add extra slot for LZMA_VLI_UNKNOWN.
-  lzma_filter filters[filters_len+1];
-
-  for(uint32_t i = 0; i < filters_len; ++i) {
-    uint64_t current = filters_handle->Get(Nan::New<Integer>(i))->Uint32Value();
-    filters[i].id = current;
-    if( current == LZMA_FILTER_LZMA2 ) {
-      filters[i].options = &opt_lzma2;
-    } else {
-      filters[i].options = NULL;
-    }
-  }
-
-  filters[filters_len] = { .id = LZMA_VLI_UNKNOWN, .options = NULL };
-
-  LZMA *self = new LZMA();
-
-  if (!self) {
-    Nan::ThrowRangeError("Out of memory, cannot create LZMAStream");
-    info.GetReturnValue().SetUndefined();
-    return;
-  }
-
-  lzma_ret ret;
-  switch(mode) {
-    case STREAM_DECODE: {
-      ret = lzma_stream_decoder(&self->_stream, UINT64_MAX, check);
-      break;
-    }
-    case STREAM_ENCODE: {
-      ret = lzma_stream_encoder(&self->_stream, filters, check);
-      break;
-    }
-#ifdef LIBLZMA_ENABLE_MT
-    case STREAM_ENCODE_MT: {
-      unsigned int threads = opts->Get(NewString("threads"))->Uint32Value();
-      lzma_mt mt = {
-        .flags = 0,
-        .threads = threads,
-        .block_size = 0,
-        .timeout = 0,
-        .preset = preset,
-        .filters = filters,
-        .check = check,
-      };
-
-      ret = lzma_stream_encoder_mt(&self->_stream, &mt);
-      break;
-    }
-#endif
-    default:
-      ret = LZMA_OPTIONS_ERROR;
-  }
-  if (ret != LZMA_OK) {
-    delete self;
-		info.GetReturnValue().Set(Nan::New<Integer>(ret));
-    return;
-  }
-
-  self->Wrap(info.This());
-  Nan::AdjustExternalMemory(sizeof(LZMA));
-
-  info.GetReturnValue().Set(info.This());
-}
-
-NAN_METHOD(LZMA::Close) {
-  LZMA_FETCH_SELF();
-  self->Close();
-  info.GetReturnValue().SetUndefined();
-}
-
-/**<
- * \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>
-NAN_METHOD(LZMA::Code) {
-  LZMA_FETCH_SELF();
-	Nan::HandleScope scope;
-
-  self->_wip = true;
-  self->Ref();
-
-  // Neat trick but that does the job :)
-  if (info.Length() != 6+(int)async) {
-    Nan::ThrowError(NewString("BUG?: LZMA::Code requires all these arguments: "
-      "flushFlag, input_buffer, input_offset, availInBefore, "
-      "output_buffer, output_offset, [callback]"));
-    info.GetReturnValue().SetUndefined();
-  }
-
-  self->_action = (lzma_action)info[0]->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 };
-    in = nada;
-    in_len = 0;
-    in_off = 0;
-  } else {
-    if (!node::Buffer::HasInstance(info[1])) {
-      Nan::ThrowTypeError(NewString("BUG?: LZMA::Code 'input_buffer' argument must be a Buffer"));
-      info.GetReturnValue().SetUndefined();
-    }
-    Local<Object> in_buf;
-    in_buf = info[1]->ToObject();
-    in_off = info[2]->Uint32Value();
-    in_len = info[3]->Uint32Value();
-
-    if(!node::Buffer::IsWithinBounds(in_off, in_len, node::Buffer::Length(in_buf))) {
-      Nan::ThrowRangeError(NewString("Offset out of bounds!"));
-      info.GetReturnValue().SetUndefined();
-    }
-    in = reinterpret_cast<const uint8_t *>(node::Buffer::Data(in_buf) + in_off);
-  }
-
-	// Check if output buffer is also a Buffer
-  Local<Object> out_buf = info[4]->ToObject();
-  if( !node::Buffer::HasInstance(out_buf) ) {
-    Nan::ThrowTypeError(NewString("BUG?: LZMA::Code 'output_buffer' argument must be a Buffer"));
-    info.GetReturnValue().SetUndefined();
-  }
-
-  out_off = info[5]->Uint32Value();
-  out_len = node::Buffer::Length(out_buf) - out_off;
-  out = reinterpret_cast<uint8_t *>(node::Buffer::Data(out_buf) + out_off);
-
-  // Only if async mode is enabled shall we need a callback function
-  if(async)
-    self->_callback.SetFunction(info[6].As<Function>());
-
-  self->_stream.next_in = in;
-  self->_stream.avail_in = in_len;
-  self->_stream.next_out = out;
-  self->_stream.avail_out = out_len;
-
-	// make us reference ourselves because of how async work_req event loop structure works
-  self->_req.data = self;
-
-  // do it synchronously
-  if(!async) {
-    Process(&(self->_req));
-		info.GetReturnValue().Set(AfterSync(self));
-    return;
-  }
-
-  // otherwise queue work, make sure we get our work done by first calling Process and then After
-  uv_queue_work(uv_default_loop(), &(self->_req), LZMA::Process, LZMA::After);
-  info.GetReturnValue().SetUndefined();
-	return;
-}
-
-void LZMA::Process(uv_work_t* work_req) {
-  LZMA* obj = static_cast<LZMA*>(work_req->data);
-
-	// the real work is done here :)
-  obj->_wip = true;
-  obj->_ret = lzma_code(&(obj->_stream), obj->_action);
-}
-
-void LZMA::After(uv_work_t* work_req, int status) {
-	Nan::HandleScope scope;
-  LZMA* obj = static_cast<LZMA*>(work_req->data);
-
-  Local<Number> ret_code = Nan::New<Number>(obj->_ret);
-  Local<Number> avail_in = Nan::New<Number>(obj->_stream.avail_in);
-  Local<Number> avail_out = Nan::New<Number>(obj->_stream.avail_out);
-  Local<Value> argv[3] = { ret_code, avail_in, avail_out };
-
-  obj->_wip = false;
-
-	obj->_callback.Call(ARRAY_SIZE(argv), argv);
-
-  obj->Unref();
-  if(obj->_pending_close) {
-    obj->Close();
-  }
-}
-
-Local<Value> LZMA::AfterSync(LZMA* obj) {
-  Local<Number> ret_code = Nan::New<Number>(obj->_ret);
-  Local<Number> avail_in = Nan::New<Number>(obj->_stream.avail_in);
-  Local<Number> avail_out = Nan::New<Number>(obj->_stream.avail_out);
-  Local<Array> result = Nan::New<Array>(3);
-  result->Set(0, ret_code);
-  result->Set(1, avail_in);
-  result->Set(2, avail_out);
-
-  obj->_wip = false;
-
-  obj->Unref();
-  if(obj->_pending_close) {
-    obj->Close();
-  }
-
-	return result;
-}

package/src/bindings/node-liblzma.hpp

@@ -1,115 +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 <node.h>
-#include <node_object_wrap.h>
-#include <v8.h>
-#include <nan.h>
-
-using v8::Array;
-using v8::Context;
-using v8::Function;
-using v8::FunctionTemplate;
-using v8::Handle;
-using v8::Local;
-using v8::Object;
-using v8::Persistent;
-using v8::String;
-using v8::Value;
-
-#include <sstream>
-
-#ifdef LIBLZMA_ENABLE_MT
-# warning "Building with (unstable) multithread support"
-# define LZMA_UNSTABLE
-#endif
-#include <lzma.h>
-
-#define STREAM_ENCODE 0
-#define STREAM_DECODE 1
-#define STREAM_ENCODE_MT 2
-
-#define CONST_UINT32(target, value) \
-  target->Set(String::NewSymbol(#value), Uint32::New(value), \
-      static_cast<PropertyAttribute>(ReadOnly|DontDelete));
-
-#ifndef ARRAY_SIZE
-# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-#endif
-
-/**
- * Create a new v8 String
- */
-template<typename T>
-inline Local<String> NewString(T value) {
-  return Nan::New<String>(value).ToLocalChecked();
-}
-
-class LZMA : public Nan::ObjectWrap {
-public:
-  static void Init(Local<Object> exports);
-
-private:
-  explicit LZMA() : ObjectWrap(), _stream(LZMA_STREAM_INIT),
-    _wip(false), _pending_close(false)
-  {
-  }
-  ~LZMA() {
-    Nan::AdjustExternalMemory(-int64_t(sizeof(LZMA)));
-    Close();
-  }
-
-  void Close();
-
-  static NAN_METHOD(New);
-  static NAN_METHOD(Close);
-
-  template<bool async>
-  static NAN_METHOD(Code);
-
-private:
-  static void Process(uv_work_t* work_req);
-  static void After(uv_work_t* work_req, int status);
-  static Local<Value> AfterSync(LZMA* obj);
-
-  static Nan::Persistent<Function> constructor;
-
-  static void _failMissingSelf(const Nan::FunctionCallbackInfo<Value>& info) {
-  	Nan::ThrowTypeError("LZMA methods need to be called on an LZMA object");
-  	info.GetReturnValue().SetUndefined();
-  }
-
-  uv_work_t _req;
-
-  lzma_stream _stream;
-  bool _wip;
-  bool _pending_close;
-
-  lzma_action _action;
-  Nan::Callback _callback;
-  lzma_ret _ret;
-};
-
-#endif // NODE_LIBLZMA_H