@mehmetb/rollup-plugin-node-builtins 3.0.1

package/src/es6/setimmediate.js

@@ -0,0 +1,185 @@
+/*
+MIT Licence
+Copyright (c) 2012 Barnesandnoble.com, llc, Donavon West, and Domenic Denicola
+https://github.com/YuzuJS/setImmediate/blob/f1ccbfdf09cb93aadf77c4aa749ea554503b9234/LICENSE.txt
+*/
+
+var nextHandle = 1; // Spec says greater than zero
+var tasksByHandle = {};
+var currentlyRunningATask = false;
+var doc = global.document;
+var registerImmediate;
+
+export function setImmediate(callback) {
+  // Callback can either be a function or a string
+  if (typeof callback !== "function") {
+    callback = new Function("" + callback);
+  }
+  // Copy function arguments
+  var args = new Array(arguments.length - 1);
+  for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i + 1];
+  }
+  // Store and register the task
+  var task = { callback: callback, args: args };
+  tasksByHandle[nextHandle] = task;
+  registerImmediate(nextHandle);
+  return nextHandle++;
+}
+
+export function clearImmediate(handle) {
+    delete tasksByHandle[handle];
+}
+
+function run(task) {
+    var callback = task.callback;
+    var args = task.args;
+    switch (args.length) {
+    case 0:
+        callback();
+        break;
+    case 1:
+        callback(args[0]);
+        break;
+    case 2:
+        callback(args[0], args[1]);
+        break;
+    case 3:
+        callback(args[0], args[1], args[2]);
+        break;
+    default:
+        callback.apply(undefined, args);
+        break;
+    }
+}
+
+function runIfPresent(handle) {
+    // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+    // So if we're currently running a task, we'll need to delay this invocation.
+    if (currentlyRunningATask) {
+        // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+        // "too much recursion" error.
+        setTimeout(runIfPresent, 0, handle);
+    } else {
+        var task = tasksByHandle[handle];
+        if (task) {
+            currentlyRunningATask = true;
+            try {
+                run(task);
+            } finally {
+                clearImmediate(handle);
+                currentlyRunningATask = false;
+            }
+        }
+    }
+}
+
+function installNextTickImplementation() {
+    registerImmediate = function(handle) {
+        process.nextTick(function () { runIfPresent(handle); });
+    };
+}
+
+function canUsePostMessage() {
+    // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+    // where `global.postMessage` means something completely different and can't be used for this purpose.
+    if (global.postMessage && !global.importScripts) {
+        var postMessageIsAsynchronous = true;
+        var oldOnMessage = global.onmessage;
+        global.onmessage = function() {
+            postMessageIsAsynchronous = false;
+        };
+        global.postMessage("", "*");
+        global.onmessage = oldOnMessage;
+        return postMessageIsAsynchronous;
+    }
+}
+
+function installPostMessageImplementation() {
+    // Installs an event handler on `global` for the `message` event: see
+    // * https://developer.mozilla.org/en/DOM/window.postMessage
+    // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+
+    var messagePrefix = "setImmediate$" + Math.random() + "$";
+    var onGlobalMessage = function(event) {
+        if (event.source === global &&
+            typeof event.data === "string" &&
+            event.data.indexOf(messagePrefix) === 0) {
+            runIfPresent(+event.data.slice(messagePrefix.length));
+        }
+    };
+
+    if (global.addEventListener) {
+        global.addEventListener("message", onGlobalMessage, false);
+    } else {
+        global.attachEvent("onmessage", onGlobalMessage);
+    }
+
+    registerImmediate = function(handle) {
+        global.postMessage(messagePrefix + handle, "*");
+    };
+}
+
+function installMessageChannelImplementation() {
+    var channel = new MessageChannel();
+    channel.port1.onmessage = function(event) {
+        var handle = event.data;
+        runIfPresent(handle);
+    };
+
+    registerImmediate = function(handle) {
+        channel.port2.postMessage(handle);
+    };
+}
+
+function installReadyStateChangeImplementation() {
+    var html = doc.documentElement;
+    registerImmediate = function(handle) {
+        // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+        // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+        var script = doc.createElement("script");
+        script.onreadystatechange = function () {
+            runIfPresent(handle);
+            script.onreadystatechange = null;
+            html.removeChild(script);
+            script = null;
+        };
+        html.appendChild(script);
+    };
+}
+
+function installSetTimeoutImplementation() {
+    registerImmediate = function(handle) {
+        setTimeout(runIfPresent, 0, handle);
+    };
+}
+
+// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
+var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
+attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
+
+// Don't get fooled by e.g. browserify environments.
+if ({}.toString.call(global.process) === "[object process]") {
+    // For Node.js before 0.9
+    installNextTickImplementation();
+
+} else if (canUsePostMessage()) {
+    // For non-IE10 modern browsers
+    installPostMessageImplementation();
+
+} else if (global.MessageChannel) {
+    // For web workers, where supported
+    installMessageChannelImplementation();
+
+} else if (doc && "onreadystatechange" in doc.createElement("script")) {
+    // For IE 6–8
+    installReadyStateChangeImplementation();
+
+} else {
+    // For older browsers
+    installSetTimeoutImplementation();
+}
+export default {
+  setTimeout: setTimeout,
+  clearTimeout: clearTimeout
+}

package/src/es6/stream.js

@@ -0,0 +1,110 @@
+import EE from 'events';
+import {inherits} from 'util';
+
+import {Duplex} from './readable-stream/duplex.js';
+import {Readable} from './readable-stream/readable.js';
+import {Writable} from './readable-stream/writable.js';
+import {Transform} from './readable-stream/transform.js';
+import {PassThrough} from './readable-stream/passthrough.js';
+inherits(Stream, EE);
+Stream.Readable = Readable;
+Stream.Writable = Writable;
+Stream.Duplex = Duplex;
+Stream.Transform = Transform;
+Stream.PassThrough = PassThrough;
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+export default Stream;
+export {Readable,Writable,Duplex,Transform,PassThrough,Stream}
+
+// old-style streams.  Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+  EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+  var source = this;
+
+  function ondata(chunk) {
+    if (dest.writable) {
+      if (false === dest.write(chunk) && source.pause) {
+        source.pause();
+      }
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  var didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    if (EE.listenerCount(this, 'error') === 0) {
+      throw er; // Unhandled stream error in pipe.
+    }
+  }
+
+  source.on('error', onerror);
+  dest.on('error', onerror);
+
+  // remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
+
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
+
+    dest.removeListener('close', cleanup);
+  }
+
+  source.on('end', cleanup);
+  source.on('close', cleanup);
+
+  dest.on('close', cleanup);
+
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
+};

package/src/es6/string-decoder.js

@@ -0,0 +1,220 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+import {Buffer} from 'buffer';
+var isBufferEncoding = Buffer.isEncoding
+  || function(encoding) {
+       switch (encoding && encoding.toLowerCase()) {
+         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+         default: return false;
+       }
+     }
+
+
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
+  }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+export function StringDecoder(encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
+  switch (this.encoding) {
+    case 'utf8':
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
+      break;
+    case 'base64':
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
+      break;
+    default:
+      this.write = passThroughWrite;
+      return;
+  }
+
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = (buffer.length >= this.charLength - this.charReceived) ?
+        this.charLength - this.charReceived :
+        buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
+
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
+  }
+
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
+
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
+  }
+
+  charStr += buffer.toString(this.encoding, 0, end);
+
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
+  }
+
+  // or just emit the charStr
+  return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
+    }
+
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
+  }
+  this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+  var res = '';
+  if (buffer && buffer.length)
+    res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
+  }
+
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
+}

package/src/es6/timers.js

@@ -0,0 +1,76 @@
+// License https://jryans.mit-license.org/
+
+import {setImmediate, clearImmediate} from './setimmediate';
+export {setImmediate, clearImmediate};
+// DOM APIs, for completeness
+var apply = Function.prototype.apply;
+
+export function clearInterval(timeout) {
+  if (typeof timeout === 'number' && typeof global.clearInterval === 'function') {
+    global.clearInterval(timeout);
+  } else {
+    clearFn(timeout)
+  }
+}
+export function clearTimeout(timeout) {
+  if (typeof timeout === 'number' && typeof global.clearTimeout === 'function') {
+    global.clearTimeout(timeout);
+  } else {
+    clearFn(timeout)
+  }
+}
+function clearFn(timeout) {
+  if (timeout && typeof timeout.close === 'function') {
+    timeout.close();
+  }
+}
+export function setTimeout() {
+  return new Timeout(apply.call(global.setTimeout, window, arguments), clearTimeout);
+}
+export function setInterval() {
+  return new Timeout(apply.call(global.setInterval, window, arguments), clearInterval);
+}
+
+function Timeout(id) {
+  this._id = id;
+}
+Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+Timeout.prototype.close = function() {
+  clearFn(this._id);
+}
+
+// Does not start the time, just sets up the members needed.
+export function enroll(item, msecs) {
+  clearTimeout(item._idleTimeoutId);
+  item._idleTimeout = msecs;
+}
+
+export function unenroll(item) {
+  clearTimeout(item._idleTimeoutId);
+  item._idleTimeout = -1;
+}
+export var _unrefActive = active;
+export function active(item) {
+  clearTimeout(item._idleTimeoutId);
+
+  var msecs = item._idleTimeout;
+  if (msecs >= 0) {
+    item._idleTimeoutId = setTimeout(function onTimeout() {
+      if (item._onTimeout)
+        item._onTimeout();
+    }, msecs);
+  }
+}
+
+export default {
+  setImmediate: setImmediate,
+  clearImmediate: clearImmediate,
+  setTimeout: setTimeout,
+  clearTimeout: clearTimeout,
+  setInterval: setInterval,
+  clearInterval: clearInterval,
+  active: active,
+  unenroll: unenroll,
+  _unrefActive: _unrefActive,
+  enroll: enroll
+};

package/src/es6/tty.js

@@ -0,0 +1,20 @@
+// MIT lisence
+// from https://github.com/substack/tty-browserify/blob/1ba769a6429d242f36226538835b4034bf6b7886/index.js
+
+export function isatty() {
+  return false;
+}
+
+export function ReadStream() {
+  throw new Error('tty.ReadStream is not implemented');
+}
+
+export function WriteStream() {
+  throw new Error('tty.ReadStream is not implemented');
+}
+
+export default {
+  isatty: isatty,
+  ReadStream: ReadStream,
+  WriteStream: WriteStream
+}