@mehmetb/rollup-plugin-node-builtins 3.0.1

package/src/es6/vm.js

@@ -0,0 +1,202 @@
+/*
+from https://github.com/substack/vm-browserify/blob/bfd7c5f59edec856dc7efe0b77a4f6b2fa20f226/index.js
+
+MIT license no Copyright holder mentioned
+*/
+
+
+function Object_keys(obj) {
+  if (Object.keys) return Object.keys(obj)
+  else {
+    var res = [];
+    for (var key in obj) res.push(key)
+    return res;
+  }
+}
+
+function forEach(xs, fn) {
+  if (xs.forEach) return xs.forEach(fn)
+  else
+    for (var i = 0; i < xs.length; i++) {
+      fn(xs[i], i, xs);
+    }
+}
+var _defineProp;
+
+function defineProp(obj, name, value) {
+  if (typeof _defineProp !== 'function') {
+    _defineProp = createDefineProp;
+  }
+  _defineProp(obj, name, value);
+}
+
+function createDefineProp() {
+  try {
+    Object.defineProperty({}, '_', {});
+    return function(obj, name, value) {
+      Object.defineProperty(obj, name, {
+        writable: true,
+        enumerable: false,
+        configurable: true,
+        value: value
+      })
+    };
+  } catch (e) {
+    return function(obj, name, value) {
+      obj[name] = value;
+    };
+  }
+}
+
+var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',
+  'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',
+  'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',
+  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',
+  'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'
+];
+
+function Context() {}
+Context.prototype = {};
+
+export function Script(code) {
+  if (!(this instanceof Script)) return new Script(code);
+  this.code = code;
+}
+function otherRunInContext(code, context) {
+  var args = Object_keys(global);
+  args.push('with (this.__ctx__){return eval(this.__code__)}');
+  var fn = Function.apply(null, args);
+  return fn.apply({
+    __code__: code,
+    __ctx__: context
+  });
+}
+Script.prototype.runInContext = function(context) {
+  if (!(context instanceof Context)) {
+    throw new TypeError('needs a \'context\' argument.');
+  }
+  if (global.document) {
+    var iframe = global.document.createElement('iframe');
+    if (!iframe.style) iframe.style = {};
+    iframe.style.display = 'none';
+
+    global.document.body.appendChild(iframe);
+
+    var win = iframe.contentWindow;
+    var wEval = win.eval,
+      wExecScript = win.execScript;
+
+    if (!wEval && wExecScript) {
+      // win.eval() magically appears when this is called in IE:
+      wExecScript.call(win, 'null');
+      wEval = win.eval;
+    }
+
+    forEach(Object_keys(context), function(key) {
+      win[key] = context[key];
+    });
+    forEach(globals, function(key) {
+      if (context[key]) {
+        win[key] = context[key];
+      }
+    });
+
+    var winKeys = Object_keys(win);
+
+    var res = wEval.call(win, this.code);
+
+    forEach(Object_keys(win), function(key) {
+      // Avoid copying circular objects like `top` and `window` by only
+      // updating existing context properties or new properties in the `win`
+      // that was only introduced after the eval.
+      if (key in context || indexOf(winKeys, key) === -1) {
+        context[key] = win[key];
+      }
+    });
+
+    forEach(globals, function(key) {
+      if (!(key in context)) {
+        defineProp(context, key, win[key]);
+      }
+    });
+    global.document.body.removeChild(iframe);
+
+    return res;
+  }
+  return otherRunInContext(this.code, context);
+};
+
+Script.prototype.runInThisContext = function() {
+  var fn = new Function('code', 'return eval(code);');
+  return fn.call(global, this.code); // maybe...
+};
+
+Script.prototype.runInNewContext = function(context) {
+  var ctx = createContext(context);
+  var res = this.runInContext(ctx);
+  if (context) {
+    forEach(Object_keys(ctx), function(key) {
+      context[key] = ctx[key];
+    });
+  }
+
+  return res;
+};
+
+
+export function createScript(code) {
+  return new Script(code);
+}
+
+export function createContext(context) {
+  if (isContext(context)) {
+    return context;
+  }
+  var copy = new Context();
+  if (typeof context === 'object') {
+    forEach(Object_keys(context), function(key) {
+      copy[key] = context[key];
+    });
+  }
+  return copy;
+}
+export function runInContext(code, contextifiedSandbox, options) {
+  var script = new Script(code, options);
+  return script.runInContext(contextifiedSandbox, options);
+}
+export function runInThisContext(code, options) {
+  var script = new Script(code, options);
+  return script.runInThisContext(options);
+}
+export function isContext(context) {
+  return context instanceof Context;
+}
+export function runInNewContext(code, sandbox, options) {
+  var script = new Script(code, options);
+  return script.runInNewContext(sandbox, options);
+}
+export default {
+  runInContext: runInContext,
+  isContext: isContext,
+  createContext: createContext,
+  createScript: createScript,
+  Script: Script,
+  runInThisContext: runInThisContext,
+  runInNewContext: runInNewContext
+}
+
+
+/*
+from indexOf
+@ author tjholowaychuk
+@ license MIT
+*/
+var _indexOf = [].indexOf;
+
+function indexOf(arr, obj){
+  if (_indexOf) return arr.indexOf(obj);
+  for (var i = 0; i < arr.length; ++i) {
+    if (arr[i] === obj) return i;
+  }
+  return -1;
+}

package/src/es6/zlib-lib/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (C) 2014-2016 by Vitaly Puzrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/src/es6/zlib-lib/adler32.js

@@ -0,0 +1,31 @@
+
+// Note: adler32 takes 12% for level 0 and 2% for level 6.
+// It doesn't worth to make additional optimizationa as in original.
+// Small size is preferable.
+
+function adler32(adler, buf, len, pos) {
+  var s1 = (adler & 0xffff) |0,
+      s2 = ((adler >>> 16) & 0xffff) |0,
+      n = 0;
+
+  while (len !== 0) {
+    // Set limit ~ twice less than 5552, to keep
+    // s2 in 31-bits, because we force signed ints.
+    // in other case %= will fail.
+    n = len > 2000 ? 2000 : len;
+    len -= n;
+
+    do {
+      s1 = (s1 + buf[pos++]) |0;
+      s2 = (s2 + s1) |0;
+    } while (--n);
+
+    s1 %= 65521;
+    s2 %= 65521;
+  }
+
+  return (s1 | (s2 << 16)) |0;
+}
+
+
+export default adler32;

package/src/es6/zlib-lib/binding.js

@@ -0,0 +1,269 @@
+import msg from './messages';
+import zstream from './zstream';
+import {deflateInit2, deflateEnd, deflateReset, deflate} from './deflate';
+import {inflateInit2, inflate, inflateEnd, inflateReset} from './inflate';
+// import constants from './constants';
+
+
+// zlib modes
+export var NONE = 0;
+export var DEFLATE = 1;
+export var INFLATE = 2;
+export var GZIP = 3;
+export var GUNZIP = 4;
+export var DEFLATERAW = 5;
+export var INFLATERAW = 6;
+export var UNZIP = 7;
+export var Z_NO_FLUSH=         0,
+  Z_PARTIAL_FLUSH=    1,
+  Z_SYNC_FLUSH=    2,
+  Z_FULL_FLUSH=       3,
+  Z_FINISH=       4,
+  Z_BLOCK=           5,
+  Z_TREES=            6,
+
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
+  Z_OK=               0,
+  Z_STREAM_END=       1,
+  Z_NEED_DICT=      2,
+  Z_ERRNO=       -1,
+  Z_STREAM_ERROR=   -2,
+  Z_DATA_ERROR=    -3,
+  //Z_MEM_ERROR:     -4,
+  Z_BUF_ERROR=    -5,
+  //Z_VERSION_ERROR: -6,
+
+  /* compression levels */
+  Z_NO_COMPRESSION=         0,
+  Z_BEST_SPEED=             1,
+  Z_BEST_COMPRESSION=       9,
+  Z_DEFAULT_COMPRESSION=   -1,
+
+
+  Z_FILTERED=               1,
+  Z_HUFFMAN_ONLY=           2,
+  Z_RLE=                    3,
+  Z_FIXED=                  4,
+  Z_DEFAULT_STRATEGY=       0,
+
+  /* Possible values of the data_type field (though see inflate()) */
+  Z_BINARY=                 0,
+  Z_TEXT=                   1,
+  //Z_ASCII:                1, // = Z_TEXT (deprecated)
+  Z_UNKNOWN=                2,
+
+  /* The deflate compression method */
+  Z_DEFLATED=               8;
+export function Zlib(mode) {
+  if (mode < DEFLATE || mode > UNZIP)
+    throw new TypeError('Bad argument');
+
+  this.mode = mode;
+  this.init_done = false;
+  this.write_in_progress = false;
+  this.pending_close = false;
+  this.windowBits = 0;
+  this.level = 0;
+  this.memLevel = 0;
+  this.strategy = 0;
+  this.dictionary = null;
+}
+
+Zlib.prototype.init = function(windowBits, level, memLevel, strategy, dictionary) {
+  this.windowBits = windowBits;
+  this.level = level;
+  this.memLevel = memLevel;
+  this.strategy = strategy;
+  // dictionary not supported.
+
+  if (this.mode === GZIP || this.mode === GUNZIP)
+    this.windowBits += 16;
+
+  if (this.mode === UNZIP)
+    this.windowBits += 32;
+
+  if (this.mode === DEFLATERAW || this.mode === INFLATERAW)
+    this.windowBits = -this.windowBits;
+
+  this.strm = new zstream();
+  var status;
+  switch (this.mode) {
+  case DEFLATE:
+  case GZIP:
+  case DEFLATERAW:
+    status = deflateInit2(
+      this.strm,
+      this.level,
+      Z_DEFLATED,
+      this.windowBits,
+      this.memLevel,
+      this.strategy
+    );
+    break;
+  case INFLATE:
+  case GUNZIP:
+  case INFLATERAW:
+  case UNZIP:
+    status  = inflateInit2(
+      this.strm,
+      this.windowBits
+    );
+    break;
+  default:
+    throw new Error('Unknown mode ' + this.mode);
+  }
+
+  if (status !== Z_OK) {
+    this._error(status);
+    return;
+  }
+
+  this.write_in_progress = false;
+  this.init_done = true;
+};
+
+Zlib.prototype.params = function() {
+  throw new Error('deflateParams Not supported');
+};
+
+Zlib.prototype._writeCheck = function() {
+  if (!this.init_done)
+    throw new Error('write before init');
+
+  if (this.mode === NONE)
+    throw new Error('already finalized');
+
+  if (this.write_in_progress)
+    throw new Error('write already in progress');
+
+  if (this.pending_close)
+    throw new Error('close is pending');
+};
+
+Zlib.prototype.write = function(flush, input, in_off, in_len, out, out_off, out_len) {
+  this._writeCheck();
+  this.write_in_progress = true;
+
+  var self = this;
+  process.nextTick(function() {
+    self.write_in_progress = false;
+    var res = self._write(flush, input, in_off, in_len, out, out_off, out_len);
+    self.callback(res[0], res[1]);
+
+    if (self.pending_close)
+      self.close();
+  });
+
+  return this;
+};
+
+// set method for Node buffers, used by pako
+function bufferSet(data, offset) {
+  for (var i = 0; i < data.length; i++) {
+    this[offset + i] = data[i];
+  }
+}
+
+Zlib.prototype.writeSync = function(flush, input, in_off, in_len, out, out_off, out_len) {
+  this._writeCheck();
+  return this._write(flush, input, in_off, in_len, out, out_off, out_len);
+};
+
+Zlib.prototype._write = function(flush, input, in_off, in_len, out, out_off, out_len) {
+  this.write_in_progress = true;
+
+  if (flush !== Z_NO_FLUSH &&
+      flush !== Z_PARTIAL_FLUSH &&
+      flush !== Z_SYNC_FLUSH &&
+      flush !== Z_FULL_FLUSH &&
+      flush !== Z_FINISH &&
+      flush !== Z_BLOCK) {
+    throw new Error('Invalid flush value');
+  }
+
+  if (input == null) {
+    input = new Buffer(0);
+    in_len = 0;
+    in_off = 0;
+  }
+
+  if (out._set)
+    out.set = out._set;
+  else
+    out.set = bufferSet;
+
+  var strm = this.strm;
+  strm.avail_in = in_len;
+  strm.input = input;
+  strm.next_in = in_off;
+  strm.avail_out = out_len;
+  strm.output = out;
+  strm.next_out = out_off;
+  var status;
+  switch (this.mode) {
+  case DEFLATE:
+  case GZIP:
+  case DEFLATERAW:
+    status = deflate(strm, flush);
+    break;
+  case UNZIP:
+  case INFLATE:
+  case GUNZIP:
+  case INFLATERAW:
+    status = inflate(strm, flush);
+    break;
+  default:
+    throw new Error('Unknown mode ' + this.mode);
+  }
+
+  if (status !== Z_STREAM_END && status !== Z_OK) {
+    this._error(status);
+  }
+
+  this.write_in_progress = false;
+  return [strm.avail_in, strm.avail_out];
+};
+
+Zlib.prototype.close = function() {
+  if (this.write_in_progress) {
+    this.pending_close = true;
+    return;
+  }
+
+  this.pending_close = false;
+
+  if (this.mode === DEFLATE || this.mode === GZIP || this.mode === DEFLATERAW) {
+    deflateEnd(this.strm);
+  } else {
+    inflateEnd(this.strm);
+  }
+
+  this.mode = NONE;
+};
+var status
+Zlib.prototype.reset = function() {
+  switch (this.mode) {
+  case DEFLATE:
+  case DEFLATERAW:
+    status = deflateReset(this.strm);
+    break;
+  case INFLATE:
+  case INFLATERAW:
+    status = inflateReset(this.strm);
+    break;
+  }
+
+  if (status !== Z_OK) {
+    this._error(status);
+  }
+};
+
+Zlib.prototype._error = function(status) {
+  this.onerror(msg[status] + ': ' + this.strm.msg, status);
+
+  this.write_in_progress = false;
+  if (this.pending_close)
+    this.close();
+};

package/src/es6/zlib-lib/crc32.js

@@ -0,0 +1,40 @@
+
+// Note: we can't get significant speed boost here.
+// So write code to minimize size - no pregenerated tables
+// and array tools dependencies.
+
+
+// Use ordinary array, since untyped makes no boost here
+function makeTable() {
+  var c, table = [];
+
+  for (var n = 0; n < 256; n++) {
+    c = n;
+    for (var k = 0; k < 8; k++) {
+      c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
+    }
+    table[n] = c;
+  }
+
+  return table;
+}
+
+// Create table on load. Just 255 signed longs. Not a problem.
+var crcTable = makeTable();
+
+
+function crc32(crc, buf, len, pos) {
+  var t = crcTable,
+      end = pos + len;
+
+  crc ^= -1;
+
+  for (var i = pos; i < end; i++) {
+    crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
+  }
+
+  return (crc ^ (-1)); // >>> 0;
+}
+
+
+export default crc32;