node-liblzma 1.1.7 → 1.1.8

package/lib/lzma.js

@@ -1,384 +1,381 @@
 // Generated by CoffeeScript 2.6.1
-(function() {
-  /*
-   * node-liblzma - Node.js bindings for liblzma
-   * Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
-   *
-   * This program is free software: you can redistribute it and/or modify
-   * it under the terms of the GNU Lesser General Public License as published by
-   * the Free Software Foundation, either version 3 of the License, or
-   * (at your option) any later version.
-   *
-   * This program is distributed in the hope that it will be useful,
-   * but WITHOUT ANY WARRANTY; without even the implied warranty of
-   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   * GNU General Public License for more details.
-   *
-   * You should have received a copy of the GNU Lesser General Public License
-   * along with this program.  If not, see <https://www.gnu.org/licenses/>.
-   */
-  var Transform, Unxz, Xz, XzStream, assert, binding_path, liblzma, maxThreads, os, path, util, xzBuffer, xzBufferSync;
-
-  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;
-
-  XzStream = class XzStream extends Transform {
-    constructor(mode, _opts = {}, options) {
-      var base, base1, base2, base3, base4;
-      super(options);
-      this._opts = _opts;
-      if ((base = this._opts).check == null) {
-        base.check = exports.check.NONE;
-      }
-      if ((base1 = this._opts).preset == null) {
-        base1.preset = exports.preset.DEFAULT;
-      }
-      if ((base2 = this._opts).filters == null) {
-        base2.filters = [exports.filter.LZMA2];
-      }
-      if ((base3 = this._opts).mode == null) {
-        base3.mode = exports.mode.NORMAL;
-      }
-      if ((base4 = this._opts).threads == null) {
-        base4.threads = 1;
-      }
-      this._chunkSize = this._opts.chunkSize ? this._opts.chunkSize : liblzma.BUFSIZ;
-      // By default no flush, since there is no LZMA_NO_SYNC, we stick to
-      // default LZMA_RUN (0)
-      this._flushFlag = this._opts.flushFlag || liblzma.LZMA_RUN;
-      assert(Array.isArray(this._opts.filters), "Filters need to be in an array!");
-      // Add default filter LZMA2 if none provided
-      if (this._opts.filters.indexOf(exports.filter.LZMA2) === -1) {
-        this._opts.filters.push(exports.filter.LZMA2);
-      }
-      // Multithreading is only available for encoding, so if we are encoding, check
-      // opts threads value.
-      if (mode === liblzma.STREAM_ENCODE) {
-        if (!liblzma.HAS_THREADS_SUPPORT) {
-          this._opts.threads = 1;
-        }
-        // By default set to maximum available processors
-        if (this._opts.threads === 0) {
-          this._opts.threads = maxThreads;
-        }
-      }
-      // Initialize engine
-      this.lzma = new liblzma.LZMA(mode, this._opts);
-      this._closed = false;
-      this._hadError = false;
-      this._offset = 0;
-      this._buffer = Buffer.alloc(this._chunkSize);
-      this.on('onerror', (errno) => {
-        var error;
-        this._hadError = true;
-        error = new Error(exports.messages[errno]);
-        error.errno = errno;
-        error.code = errno;
-        return this.emit('error', error);
-      });
-      this.once('end', this.close);
+/*
+ * node-liblzma - Node.js bindings for liblzma
+ * Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+var Transform, Unxz, Xz, XzStream, assert, binding_path, liblzma, maxThreads, os, path, util, xzBuffer, xzBufferSync;
+
+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;
+
+XzStream = class XzStream extends Transform {
+  constructor(mode, _opts = {}, options) {
+    var base, base1, base2, base3, base4;
+    super(options);
+    this._opts = _opts;
+    if ((base = this._opts).check == null) {
+      base.check = exports.check.NONE;
     }
-
-    flush(kind, callback) {
-      var ws;
-      ws = this._writableState;
-      if (typeof kind === 'function' || (typeof kind === 'undefined' && !callback)) {
-        [callback, kind] = [kind, liblzma.LZMA_SYNC_FLUSH];
+    if ((base1 = this._opts).preset == null) {
+      base1.preset = exports.preset.DEFAULT;
+    }
+    if ((base2 = this._opts).filters == null) {
+      base2.filters = [exports.filter.LZMA2];
+    }
+    if ((base3 = this._opts).mode == null) {
+      base3.mode = exports.mode.NORMAL;
+    }
+    if ((base4 = this._opts).threads == null) {
+      base4.threads = 1;
+    }
+    this._chunkSize = this._opts.chunkSize ? this._opts.chunkSize : liblzma.BUFSIZ;
+    // By default no flush, since there is no LZMA_NO_SYNC, we stick to
+    // default LZMA_RUN (0)
+    this._flushFlag = this._opts.flushFlag || liblzma.LZMA_RUN;
+    assert(Array.isArray(this._opts.filters), "Filters need to be in an array!");
+    // Add default filter LZMA2 if none provided
+    if (this._opts.filters.indexOf(exports.filter.LZMA2) === -1) {
+      this._opts.filters.push(exports.filter.LZMA2);
+    }
+    // Multithreading is only available for encoding, so if we are encoding, check
+    // opts threads value.
+    if (mode === liblzma.STREAM_ENCODE) {
+      if (!liblzma.HAS_THREADS_SUPPORT) {
+        this._opts.threads = 1;
       }
-      if (ws.ended) {
-        if (callback) {
-          process.nextTick(callback);
-        }
-      } else if (ws.ending) {
-        if (callback) {
-          this.once('end', callback);
-        }
-      } else if (ws.needDrain) {
-        this.once('drain', () => {
-          this.flush(callback);
-        });
-      } else {
-        this._flushFlag = kind;
-        this.write(Buffer.alloc(0), '', callback);
+      // By default set to maximum available processors
+      if (this._opts.threads === 0) {
+        this._opts.threads = maxThreads;
       }
     }
-
-    close(callback) {
+    // Initialize engine
+    this.lzma = new liblzma.LZMA(mode, this._opts);
+    this._closed = false;
+    this._hadError = false;
+    this._offset = 0;
+    this._buffer = Buffer.alloc(this._chunkSize);
+    this.on('onerror', (errno) => {
+      var error;
+      this._hadError = true;
+      error = new Error(exports.messages[errno]);
+      error.errno = errno;
+      error.code = errno;
+      return this.emit('error', error);
+    });
+    this.once('end', this.close);
+  }
+
+  flush(kind, callback) {
+    var ws;
+    ws = this._writableState;
+    if (typeof kind === 'function' || (typeof kind === 'undefined' && !callback)) {
+      [callback, kind] = [kind, liblzma.LZMA_SYNC_FLUSH];
+    }
+    if (ws.ended) {
       if (callback) {
         process.nextTick(callback);
       }
-      // We will trigger this case with #xz and #unxz
-      if (this._closed) {
-        return;
+    } else if (ws.ending) {
+      if (callback) {
+        this.once('end', callback);
       }
-      this.lzma.close();
-      this._closed = true;
-      process.nextTick(() => {
-        this.emit('close');
+    } else if (ws.needDrain) {
+      this.once('drain', () => {
+        this.flush(callback);
       });
+    } else {
+      this._flushFlag = kind;
+      this.write(Buffer.alloc(0), '', callback);
     }
+  }
 
-    _transform(chunk, encoding, callback) {
-      var ending, flushFlag, last, ws;
-      flushFlag = void 0;
-      ws = this._writableState;
-      ending = ws.ending || ws.ended;
-      last = ending && (!chunk || ws.length === chunk.length);
-      if (chunk !== null && !(chunk instanceof Buffer)) {
-        return callback(new Error("invalid input"));
+  close(callback) {
+    if (callback) {
+      process.nextTick(callback);
+    }
+    // We will trigger this case with #xz and #unxz
+    if (this._closed) {
+      return;
+    }
+    this.lzma.close();
+    this._closed = true;
+    process.nextTick(() => {
+      this.emit('close');
+    });
+  }
+
+  _transform(chunk, encoding, callback) {
+    var ending, flushFlag, last, ws;
+    flushFlag = void 0;
+    ws = this._writableState;
+    ending = ws.ending || ws.ended;
+    last = ending && (!chunk || ws.length === chunk.length);
+    if (chunk !== null && !(chunk instanceof Buffer)) {
+      return callback(new Error("invalid input"));
+    }
+    if (this._closed) {
+      return callback(new Error("lzma binding 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 = this._flushFlag;
+      if (chunk.length >= ws.length) {
+        // once we've flushed the last of the queue, stop flushing and
+        // go back to the normal behavior.
+        this._flushFlag = this._opts.flushFlag || liblzma.LZMA_RUN;
       }
-      if (this._closed) {
-        return callback(new Error("lzma binding closed"));
+    }
+    this._processChunk(chunk, flushFlag, callback);
+  }
+
+  _flush(callback) {
+    this._transform(Buffer.alloc(0), '', callback);
+  }
+
+  _processChunk(chunk, flushFlag, cb) {
+    var async, availInBefore, availOutBefore, buf, buffers, callback, error, inOff, nread, res;
+    // 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(!this._closed, "Stream closed!");
+    availInBefore = chunk && chunk.length;
+    availOutBefore = this._chunkSize - this._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) => {
+      var out, used;
+      if (this._hadError) {
+        return;
       }
-      // 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 = this._flushFlag;
-        if (chunk.length >= ws.length) {
-          // once we've flushed the last of the queue, stop flushing and
-          // go back to the normal behavior.
-          this._flushFlag = this._opts.flushFlag || liblzma.LZMA_RUN;
-        }
+      // if LZMA engine returned something else, we are running into trouble!
+      if (errno !== liblzma.LZMA_OK && errno !== liblzma.LZMA_STREAM_END) {
+        this.emit('onerror', errno);
+        return false;
       }
-      this._processChunk(chunk, flushFlag, callback);
-    }
-
-    _flush(callback) {
-      this._transform(Buffer.alloc(0), '', callback);
-    }
-
-    _processChunk(chunk, flushFlag, cb) {
-      var async, availInBefore, availOutBefore, buf, buffers, callback, error, inOff, nread, res;
-      // 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(!this._closed, "Stream closed!");
-      availInBefore = chunk && chunk.length;
-      availOutBefore = this._chunkSize - this._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) => {
-        var out, used;
-        if (this._hadError) {
-          return;
-        }
-        // if LZMA engine returned something else, we are running into trouble!
-        if (errno !== liblzma.LZMA_OK && errno !== liblzma.LZMA_STREAM_END) {
-          this.emit('onerror', errno);
-          return false;
-        }
-        used = availOutBefore - availOutAfter;
-        assert(used >= 0, `More bytes after than before! Delta = ${used}`);
-        if (used > 0) {
-          out = this._buffer.slice(this._offset, this._offset + used);
-          this._offset += used;
-          if (async) {
-            this.push(out);
-          } else {
-            buffers.push(out);
-            nread += used;
-          }
-        }
-        // exhausted the output buffer, or used all the input create a new one.
-        if (availOutAfter === 0 || this._offset >= this._chunkSize) {
-          availOutBefore = this._chunkSize;
-          this._offset = 0;
-          this._buffer = Buffer.alloc(this._chunkSize);
-        }
-        if (availOutAfter === 0 || availInAfter > 0) {
-          inOff += availInBefore - availInAfter;
-          availInBefore = availInAfter;
-          if (!async) {
-            return true;
-          }
-          this.lzma.code(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, callback);
-          return;
+      used = availOutBefore - availOutAfter;
+      assert(used >= 0, `More bytes after than before! Delta = ${used}`);
+      if (used > 0) {
+        out = this._buffer.slice(this._offset, this._offset + used);
+        this._offset += used;
+        if (async) {
+          this.push(out);
+        } else {
+          buffers.push(out);
+          nread += used;
         }
+      }
+      // exhausted the output buffer, or used all the input create a new one.
+      if (availOutAfter === 0 || this._offset >= this._chunkSize) {
+        availOutBefore = this._chunkSize;
+        this._offset = 0;
+        this._buffer = Buffer.alloc(this._chunkSize);
+      }
+      if (availOutAfter === 0 || availInAfter > 0) {
+        inOff += availInBefore - availInAfter;
+        availInBefore = availInAfter;
         if (!async) {
-          return false;
+          return true;
         }
-        cb();
-      };
+        this.lzma.code(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, callback);
+        return;
+      }
       if (!async) {
-        // Doing it synchronously
-        buffers = [];
-        nread = 0;
-        error = null;
-        this.on('error', function(e) {
-          return error = e;
-        });
-        while (true) {
-          res = this.lzma.codeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset);
-          if (!(!this._hadError && callback(res[0], res[1], res[2]))) {
-            break;
-          }
-        }
-        if (this._hadError) {
-          throw error;
+        return false;
+      }
+      cb();
+    };
+    if (!async) {
+      // Doing it synchronously
+      buffers = [];
+      nread = 0;
+      error = null;
+      this.on('error', function(e) {
+        return error = e;
+      });
+      while (true) {
+        res = this.lzma.codeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset);
+        if (!(!this._hadError && callback(res[0], res[1], res[2]))) {
+          break;
         }
-        this.close();
-        buf = Buffer.concat(buffers, nread);
-        return buf;
       }
-      this.lzma.code(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, callback);
-    }
-
-  };
-
-  Xz = class Xz extends XzStream {
-    constructor(lzma_options, options) {
-      super(liblzma.STREAM_ENCODE, lzma_options, options);
-    }
-
-  };
-
-  Unxz = class Unxz extends XzStream {
-    constructor(lzma_options, options) {
-      super(liblzma.STREAM_DECODE, lzma_options, options);
-    }
-
-  };
-
-  exports.Xz = Xz;
-
-  exports.Unxz = Unxz;
-
-  exports.hasThreads = function() {
-    return 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 = function(lzma_options, options) {
-    return new Xz(lzma_options, options);
-  };
-
-  exports.createUnxz = function(lzma_options, options) {
-    return new Unxz(lzma_options, options);
-  };
-
-  exports.unxz = function(buffer, opts, callback) {
-    if (typeof opts === 'function') {
-      [callback, opts] = [opts, {}];
+      if (this._hadError) {
+        throw error;
+      }
+      this.close();
+      buf = Buffer.concat(buffers, nread);
+      return buf;
     }
-    return xzBuffer(new Unxz(opts), buffer, callback);
-  };
-
-  exports.unxzSync = function(buffer, opts) {
-    return xzBufferSync(new Unxz(opts), buffer);
-  };
-
-  exports.xz = function(buffer, opts, callback) {
-    if (typeof opts === 'function') {
-      [callback, opts] = [opts, {}];
+    this.lzma.code(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, callback);
+  }
+
+};
+
+Xz = class Xz extends XzStream {
+  constructor(lzma_options, options) {
+    super(liblzma.STREAM_ENCODE, lzma_options, options);
+  }
+
+};
+
+Unxz = class Unxz extends XzStream {
+  constructor(lzma_options, options) {
+    super(liblzma.STREAM_DECODE, lzma_options, options);
+  }
+
+};
+
+exports.Xz = Xz;
+
+exports.Unxz = Unxz;
+
+exports.hasThreads = function() {
+  return 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 = function(lzma_options, options) {
+  return new Xz(lzma_options, options);
+};
+
+exports.createUnxz = function(lzma_options, options) {
+  return new Unxz(lzma_options, options);
+};
+
+exports.unxz = function(buffer, opts, callback) {
+  if (typeof opts === 'function') {
+    [callback, opts] = [opts, {}];
+  }
+  return xzBuffer(new Unxz(opts), buffer, callback);
+};
+
+exports.unxzSync = function(buffer, opts) {
+  return xzBufferSync(new Unxz(opts), buffer);
+};
+
+exports.xz = function(buffer, opts, callback) {
+  if (typeof opts === 'function') {
+    [callback, opts] = [opts, {}];
+  }
+  return xzBuffer(new Xz(opts), buffer, callback);
+};
+
+exports.xzSync = function(buffer, opts) {
+  return xzBufferSync(new Xz(opts), buffer);
+};
+
+xzBuffer = function(engine, buffer, callback) {
+  var buffers, flow, nread, onEnd, onError;
+  buffers = [];
+  nread = 0;
+  flow = function() {
+    var chunk;
+    chunk = void 0;
+    while (null !== (chunk = engine.read())) {
+      buffers.push(chunk);
+      nread += chunk.length;
     }
-    return xzBuffer(new Xz(opts), buffer, callback);
-  };
-
-  exports.xzSync = function(buffer, opts) {
-    return xzBufferSync(new Xz(opts), buffer);
+    engine.once('readable', flow);
   };
-
-  xzBuffer = function(engine, buffer, callback) {
-    var buffers, flow, nread, onEnd, onError;
+  onEnd = function() {
+    var buf;
+    buf = Buffer.concat(buffers, nread);
     buffers = [];
-    nread = 0;
-    flow = function() {
-      var chunk;
-      chunk = void 0;
-      while (null !== (chunk = engine.read())) {
-        buffers.push(chunk);
-        nread += chunk.length;
-      }
-      engine.once('readable', flow);
-    };
-    onEnd = function() {
-      var buf;
-      buf = Buffer.concat(buffers, nread);
-      buffers = [];
-      callback(null, buf);
-      engine.close();
-    };
-    onError = function(err) {
-      engine.removeListener('end', onEnd);
-      engine.removeListener('readable', flow);
-      callback(err);
-    };
-    engine.on('error', onError);
-    engine.on('end', onEnd);
-    engine.end(buffer);
-    flow();
+    callback(null, buf);
+    engine.close();
   };
-
-  xzBufferSync = function(engine, buffer) {
-    if (typeof buffer === 'string') {
-      buffer = Buffer.from(buffer);
-    }
-    if (!(buffer instanceof Buffer)) {
-      throw new TypeError("Not a string or buffer");
-    }
-    return engine._processChunk(buffer, liblzma.LZMA_FINISH);
+  onError = function(err) {
+    engine.removeListener('end', onEnd);
+    engine.removeListener('readable', flow);
+    callback(err);
   };
-
-  module.exports = exports;
-
-}).call(this);
+  engine.on('error', onError);
+  engine.on('end', onEnd);
+  engine.end(buffer);
+  flow();
+};
+
+xzBufferSync = function(engine, buffer) {
+  if (typeof buffer === 'string') {
+    buffer = Buffer.from(buffer);
+  }
+  if (!(buffer instanceof Buffer)) {
+    throw new TypeError("Not a string or buffer");
+  }
+  return engine._processChunk(buffer, liblzma.LZMA_FINISH);
+};
+
+module.exports = exports;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "node-liblzma",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "NodeJS wrapper for liblzma",
   "main": "./lib/lzma.js",
   "scripts": {
     "install": "node-gyp-build",
-    "prepare": "npx ynpx coffeescript --compile --output lib/ src/",
+    "prepare": "npx ynpx coffeescript --bare --compile --output lib/ src/",
     "prebuildify": "npx prebuildify --napi --strip -t $(node -v)",
     "prebuildify:win": "for /f \"usebackq tokens=*\" %v in (`node -v`) do npx prebuildify -t %v --napi --strip",
     "test": "mocha test/*.coffee"