Initial project import

node_modules/promise-worker-transferable/dist/promise-worker.js

@@ -0,0 +1,404 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.PromiseWorker = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (global){
+'use strict';
+var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+var scheduleDrain;
+
+{
+  if (Mutation) {
+    var called = 0;
+    var observer = new Mutation(nextTick);
+    var element = global.document.createTextNode('');
+    observer.observe(element, {
+      characterData: true
+    });
+    scheduleDrain = function () {
+      element.data = (called = ++called % 2);
+    };
+  } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
+    var channel = new global.MessageChannel();
+    channel.port1.onmessage = nextTick;
+    scheduleDrain = function () {
+      channel.port2.postMessage(0);
+    };
+  } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
+    scheduleDrain = function () {
+
+      // 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 scriptEl = global.document.createElement('script');
+      scriptEl.onreadystatechange = function () {
+        nextTick();
+
+        scriptEl.onreadystatechange = null;
+        scriptEl.parentNode.removeChild(scriptEl);
+        scriptEl = null;
+      };
+      global.document.documentElement.appendChild(scriptEl);
+    };
+  } else {
+    scheduleDrain = function () {
+      setTimeout(nextTick, 0);
+    };
+  }
+}
+
+var draining;
+var queue = [];
+//named nextTick for less confusing stack traces
+function nextTick() {
+  draining = true;
+  var i, oldQueue;
+  var len = queue.length;
+  while (len) {
+    oldQueue = queue;
+    queue = [];
+    i = -1;
+    while (++i < len) {
+      oldQueue[i]();
+    }
+    len = queue.length;
+  }
+  draining = false;
+}
+
+module.exports = immediate;
+function immediate(task) {
+  if (queue.push(task) === 1 && !draining) {
+    scheduleDrain();
+  }
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],2:[function(require,module,exports){
+'use strict';
+var immediate = require(1);
+
+/* istanbul ignore next */
+function INTERNAL() {}
+
+var handlers = {};
+
+var REJECTED = ['REJECTED'];
+var FULFILLED = ['FULFILLED'];
+var PENDING = ['PENDING'];
+
+module.exports = Promise;
+
+function Promise(resolver) {
+  if (typeof resolver !== 'function') {
+    throw new TypeError('resolver must be a function');
+  }
+  this.state = PENDING;
+  this.queue = [];
+  this.outcome = void 0;
+  if (resolver !== INTERNAL) {
+    safelyResolveThenable(this, resolver);
+  }
+}
+
+Promise.prototype["catch"] = function (onRejected) {
+  return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+  if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
+    typeof onRejected !== 'function' && this.state === REJECTED) {
+    return this;
+  }
+  var promise = new this.constructor(INTERNAL);
+  if (this.state !== PENDING) {
+    var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
+    unwrap(promise, resolver, this.outcome);
+  } else {
+    this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+  }
+
+  return promise;
+};
+function QueueItem(promise, onFulfilled, onRejected) {
+  this.promise = promise;
+  if (typeof onFulfilled === 'function') {
+    this.onFulfilled = onFulfilled;
+    this.callFulfilled = this.otherCallFulfilled;
+  }
+  if (typeof onRejected === 'function') {
+    this.onRejected = onRejected;
+    this.callRejected = this.otherCallRejected;
+  }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+  handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+  unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+  handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+  unwrap(this.promise, this.onRejected, value);
+};
+
+function unwrap(promise, func, value) {
+  immediate(function () {
+    var returnValue;
+    try {
+      returnValue = func(value);
+    } catch (e) {
+      return handlers.reject(promise, e);
+    }
+    if (returnValue === promise) {
+      handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+    } else {
+      handlers.resolve(promise, returnValue);
+    }
+  });
+}
+
+handlers.resolve = function (self, value) {
+  var result = tryCatch(getThen, value);
+  if (result.status === 'error') {
+    return handlers.reject(self, result.value);
+  }
+  var thenable = result.value;
+
+  if (thenable) {
+    safelyResolveThenable(self, thenable);
+  } else {
+    self.state = FULFILLED;
+    self.outcome = value;
+    var i = -1;
+    var len = self.queue.length;
+    while (++i < len) {
+      self.queue[i].callFulfilled(value);
+    }
+  }
+  return self;
+};
+handlers.reject = function (self, error) {
+  self.state = REJECTED;
+  self.outcome = error;
+  var i = -1;
+  var len = self.queue.length;
+  while (++i < len) {
+    self.queue[i].callRejected(error);
+  }
+  return self;
+};
+
+function getThen(obj) {
+  // Make sure we only access the accessor once as required by the spec
+  var then = obj && obj.then;
+  if (obj && typeof obj === 'object' && typeof then === 'function') {
+    return function appyThen() {
+      then.apply(obj, arguments);
+    };
+  }
+}
+
+function safelyResolveThenable(self, thenable) {
+  // Either fulfill, reject or reject with error
+  var called = false;
+  function onError(value) {
+    if (called) {
+      return;
+    }
+    called = true;
+    handlers.reject(self, value);
+  }
+
+  function onSuccess(value) {
+    if (called) {
+      return;
+    }
+    called = true;
+    handlers.resolve(self, value);
+  }
+
+  function tryToUnwrap() {
+    thenable(onSuccess, onError);
+  }
+
+  var result = tryCatch(tryToUnwrap);
+  if (result.status === 'error') {
+    onError(result.value);
+  }
+}
+
+function tryCatch(func, value) {
+  var out = {};
+  try {
+    out.value = func(value);
+    out.status = 'success';
+  } catch (e) {
+    out.status = 'error';
+    out.value = e;
+  }
+  return out;
+}
+
+Promise.resolve = resolve;
+function resolve(value) {
+  if (value instanceof this) {
+    return value;
+  }
+  return handlers.resolve(new this(INTERNAL), value);
+}
+
+Promise.reject = reject;
+function reject(reason) {
+  var promise = new this(INTERNAL);
+  return handlers.reject(promise, reason);
+}
+
+Promise.all = all;
+function all(iterable) {
+  var self = this;
+  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+    return this.reject(new TypeError('must be an array'));
+  }
+
+  var len = iterable.length;
+  var called = false;
+  if (!len) {
+    return this.resolve([]);
+  }
+
+  var values = new Array(len);
+  var resolved = 0;
+  var i = -1;
+  var promise = new this(INTERNAL);
+
+  while (++i < len) {
+    allResolver(iterable[i], i);
+  }
+  return promise;
+  function allResolver(value, i) {
+    self.resolve(value).then(resolveFromAll, function (error) {
+      if (!called) {
+        called = true;
+        handlers.reject(promise, error);
+      }
+    });
+    function resolveFromAll(outValue) {
+      values[i] = outValue;
+      if (++resolved === len && !called) {
+        called = true;
+        handlers.resolve(promise, values);
+      }
+    }
+  }
+}
+
+Promise.race = race;
+function race(iterable) {
+  var self = this;
+  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+    return this.reject(new TypeError('must be an array'));
+  }
+
+  var len = iterable.length;
+  var called = false;
+  if (!len) {
+    return this.resolve([]);
+  }
+
+  var i = -1;
+  var promise = new this(INTERNAL);
+
+  while (++i < len) {
+    resolver(iterable[i]);
+  }
+  return promise;
+  function resolver(value) {
+    self.resolve(value).then(function (response) {
+      if (!called) {
+        called = true;
+        handlers.resolve(promise, response);
+      }
+    }, function (error) {
+      if (!called) {
+        called = true;
+        handlers.reject(promise, error);
+      }
+    });
+  }
+}
+
+},{"1":1}],3:[function(require,module,exports){
+'use strict';
+
+/* istanbul ignore next */
+var MyPromise = typeof Promise !== 'undefined' ? Promise : require(2);
+
+var messageIds = 0;
+
+function onMessage(self, e) {
+  var message = e.data;
+  if (!Array.isArray(message) || message.length < 2) {
+    // Ignore - this message is not for us.
+    return;
+  }
+  var messageId = message[0];
+  var error = message[1];
+  var result = message[2];
+
+  var callback = self._callbacks[messageId];
+
+  if (!callback) {
+    // Ignore - user might have created multiple PromiseWorkers.
+    // This message is not for us.
+    return;
+  }
+
+  delete self._callbacks[messageId];
+  callback(error, result);
+}
+
+function PromiseWorker(worker) {
+  var self = this;
+  self._worker = worker;
+  self._callbacks = {};
+
+  worker.addEventListener('message', function (e) {
+    onMessage(self, e);
+  });
+}
+
+PromiseWorker.prototype.postMessage = function (userMessage, transferList) {
+  var self = this;
+  var messageId = messageIds++;
+
+  var messageToSend = [messageId, userMessage];
+
+  return new MyPromise(function (resolve, reject) {
+    self._callbacks[messageId] = function (error, result) {
+      if (error) {
+        return reject(new Error(error.message));
+      }
+      resolve(result);
+    };
+    /* istanbul ignore if */
+    if (typeof self._worker.controller !== 'undefined') {
+      // service worker, use MessageChannels because e.source is broken in Chrome < 51:
+      // https://bugs.chromium.org/p/chromium/issues/detail?id=543198
+      var channel = new MessageChannel();
+      channel.port1.onmessage = function (e) {
+        onMessage(self, e);
+      };
+      self._worker.controller.postMessage(messageToSend, [channel.port2].concat(transferList));
+    } else {
+      // web worker
+      self._worker.postMessage(messageToSend, transferList);
+    }
+  });
+};
+
+PromiseWorker.prototype.terminate = function () {
+    this._worker.terminate();
+}
+
+module.exports = PromiseWorker;
+},{"2":2}]},{},[3])(3)
+});

node_modules/promise-worker-transferable/dist/promise-worker.register.js

@@ -0,0 +1,100 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.registerPromiseWorker = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+module.exports = isPromise;
+
+function isPromise(obj) {
+  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+}
+
+},{}],2:[function(require,module,exports){
+'use strict';
+
+var isPromise = require(1);
+
+function registerPromiseWorker(callback) {
+
+  function postOutgoingMessage(e, messageId, error, result) {
+    function postMessage(msg, transferList) {
+      /* istanbul ignore if */
+      if (typeof self.postMessage !== 'function') { // service worker
+        e.ports[0].postMessage(msg, transferList);
+      } else { // web worker
+        self.postMessage(msg, transferList);
+      }
+    }
+    if (error) {
+      /* istanbul ignore else */
+      if (typeof console !== 'undefined' && 'error' in console) {
+        // This is to make errors easier to debug. I think it's important
+        // enough to just leave here without giving the user an option
+        // to silence it.
+        console.error('Worker caught an error:', error);
+      }
+      postMessage([messageId, {
+        message: error.message
+      }]);
+    } else {
+      if (result instanceof MessageWithTransferList) {
+        postMessage([messageId, null, result.message], result.transferList);
+      } else {
+        postMessage([messageId, null, result]);
+      }
+    }
+  }
+
+  function tryCatchFunc(callback, message) {
+    try {
+      return {res: callback(message, withTransferList)};
+    } catch (e) {
+      return {err: e};
+    }
+  }
+
+  function withTransferList(resMessage, transferList) {
+    return new MessageWithTransferList(resMessage, transferList);
+  } 
+
+  function handleIncomingMessage(e, callback, messageId, message) {
+
+    var result = tryCatchFunc(callback, message);
+
+    if (result.err) {
+      postOutgoingMessage(e, messageId, result.err);
+    } else if (!isPromise(result.res)) {
+        postOutgoingMessage(e, messageId, null, result.res);
+    } else {
+      result.res.then(function (finalResult) {
+        postOutgoingMessage(e, messageId, null, finalResult);
+      }, function (finalError) {
+        postOutgoingMessage(e, messageId, finalError);
+      });
+    }
+  }
+
+  function onIncomingMessage(e) {
+    var payload = e.data;
+    if (!Array.isArray(payload) || payload.length !== 2) {
+      // message doens't match communication format; ignore
+      return;
+    }
+    var messageId = payload[0];
+    var message = payload[1];
+
+    if (typeof callback !== 'function') {
+      postOutgoingMessage(e, messageId, new Error(
+        'Please pass a function into register().'));
+    } else {
+      handleIncomingMessage(e, callback, messageId, message);
+    }
+  }
+
+  function MessageWithTransferList(message, transferList) {
+    this.message = message;
+    this.transferList = transferList;
+  }
+
+  self.addEventListener('message', onIncomingMessage);
+}
+
+module.exports = registerPromiseWorker;
+},{"1":1}]},{},[2])(2)
+});

node_modules/promise-worker-transferable/dist/promise-worker.register.min.js

@@ -0,0 +1 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var n;n="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,n.registerPromiseWorker=e()}}(function(){return function e(n,r,t){function o(i,s){if(!r[i]){if(!n[i]){var u="function"==typeof require&&require;if(!s&&u)return u(i,!0);if(f)return f(i,!0);var c=new Error("Cannot find module '"+i+"'");throw c.code="MODULE_NOT_FOUND",c}var a=r[i]={exports:{}};n[i][0].call(a.exports,function(e){var r=n[i][1][e];return o(r?r:e)},a,a.exports,e,n,r,t)}return r[i].exports}for(var f="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}({1:[function(e,n,r){function t(e){return!!e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof e.then}n.exports=t},{}],2:[function(e,n,r){"use strict";function t(e){function n(e,n,r,t){function o(n,r){"function"!=typeof self.postMessage?e.ports[0].postMessage(n,r):self.postMessage(n,r)}r?("undefined"!=typeof console&&"error"in console&&console.error("Worker caught an error:",r),o([n,{message:r.message}])):t instanceof s?o([n,null,t.message],t.transferList):o([n,null,t])}function r(e,n){try{return{res:e(n,t)}}catch(e){return{err:e}}}function t(e,n){return new s(e,n)}function f(e,t,f,i){var s=r(t,i);s.err?n(e,f,s.err):o(s.res)?s.res.then(function(r){n(e,f,null,r)},function(r){n(e,f,r)}):n(e,f,null,s.res)}function i(r){var t=r.data;if(Array.isArray(t)&&2===t.length){var o=t[0],i=t[1];"function"!=typeof e?n(r,o,new Error("Please pass a function into register().")):f(r,e,o,i)}}function s(e,n){this.message=e,this.transferList=n}self.addEventListener("message",i)}var o=e(1);n.exports=t},{1:1}]},{},[2])(2)});