diff --git a/dist/image-sequencer.js b/dist/image-sequencer.js index 988e2dd3..283251d0 100644 --- a/dist/image-sequencer.js +++ b/dist/image-sequencer.js @@ -358,8 +358,5658 @@ exports.nextCombination = function(v) { },{}],3:[function(require,module,exports){ +(function (process,global,setImmediate){ +/* @preserve + * The MIT License (MIT) + * + * Copyright (c) 2013-2018 Petka Antonov + * + * 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. + * + */ +/** + * bluebird build version 3.5.2 + * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each +*/ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;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 _dereq_=="function"&&_dereq_;for(var o=0;o 0) { + _drainQueueStep(queue); + } +} + +function _drainQueueStep(queue) { + var fn = queue.shift(); + if (typeof fn !== "function") { + fn._settlePromises(); + } else { + var receiver = queue.shift(); + var arg = queue.shift(); + fn.call(receiver, arg); + } +} + +Async.prototype._drainQueues = function () { + _drainQueue(this._normalQueue); + this._reset(); + this._haveDrainedQueues = true; + _drainQueue(this._lateQueue); +}; + +Async.prototype._queueTick = function () { + if (!this._isTickUsed) { + this._isTickUsed = true; + this._schedule(this.drainQueues); + } +}; + +Async.prototype._reset = function () { + this._isTickUsed = false; +}; + +module.exports = Async; +module.exports.firstLineError = firstLineError; + +},{"./queue":26,"./schedule":29,"./util":36}],3:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) { +var calledBind = false; +var rejectThis = function(_, e) { + this._reject(e); +}; + +var targetRejected = function(e, context) { + context.promiseRejectionQueued = true; + context.bindingPromise._then(rejectThis, rejectThis, null, this, e); +}; + +var bindingResolved = function(thisArg, context) { + if (((this._bitField & 50397184) === 0)) { + this._resolveCallback(context.target); + } +}; + +var bindingRejected = function(e, context) { + if (!context.promiseRejectionQueued) this._reject(e); +}; + +Promise.prototype.bind = function (thisArg) { + if (!calledBind) { + calledBind = true; + Promise.prototype._propagateFrom = debug.propagateFromFunction(); + Promise.prototype._boundValue = debug.boundValueFunction(); + } + var maybePromise = tryConvertToPromise(thisArg); + var ret = new Promise(INTERNAL); + ret._propagateFrom(this, 1); + var target = this._target(); + ret._setBoundTo(maybePromise); + if (maybePromise instanceof Promise) { + var context = { + promiseRejectionQueued: false, + promise: ret, + target: target, + bindingPromise: maybePromise + }; + target._then(INTERNAL, targetRejected, undefined, ret, context); + maybePromise._then( + bindingResolved, bindingRejected, undefined, ret, context); + ret._setOnCancel(maybePromise); + } else { + ret._resolveCallback(target); + } + return ret; +}; + +Promise.prototype._setBoundTo = function (obj) { + if (obj !== undefined) { + this._bitField = this._bitField | 2097152; + this._boundTo = obj; + } else { + this._bitField = this._bitField & (~2097152); + } +}; + +Promise.prototype._isBound = function () { + return (this._bitField & 2097152) === 2097152; +}; + +Promise.bind = function (thisArg, value) { + return Promise.resolve(value).bind(thisArg); +}; +}; + +},{}],4:[function(_dereq_,module,exports){ +"use strict"; +var old; +if (typeof Promise !== "undefined") old = Promise; +function noConflict() { + try { if (Promise === bluebird) Promise = old; } + catch (e) {} + return bluebird; +} +var bluebird = _dereq_("./promise")(); +bluebird.noConflict = noConflict; +module.exports = bluebird; + +},{"./promise":22}],5:[function(_dereq_,module,exports){ +"use strict"; +var cr = Object.create; +if (cr) { + var callerCache = cr(null); + var getterCache = cr(null); + callerCache[" size"] = getterCache[" size"] = 0; +} + +module.exports = function(Promise) { +var util = _dereq_("./util"); +var canEvaluate = util.canEvaluate; +var isIdentifier = util.isIdentifier; + +var getMethodCaller; +var getGetter; +if (!true) { +var makeMethodCaller = function (methodName) { + return new Function("ensureMethod", " \n\ + return function(obj) { \n\ + 'use strict' \n\ + var len = this.length; \n\ + ensureMethod(obj, 'methodName'); \n\ + switch(len) { \n\ + case 1: return obj.methodName(this[0]); \n\ + case 2: return obj.methodName(this[0], this[1]); \n\ + case 3: return obj.methodName(this[0], this[1], this[2]); \n\ + case 0: return obj.methodName(); \n\ + default: \n\ + return obj.methodName.apply(obj, this); \n\ + } \n\ + }; \n\ + ".replace(/methodName/g, methodName))(ensureMethod); +}; + +var makeGetter = function (propertyName) { + return new Function("obj", " \n\ + 'use strict'; \n\ + return obj.propertyName; \n\ + ".replace("propertyName", propertyName)); +}; + +var getCompiled = function(name, compiler, cache) { + var ret = cache[name]; + if (typeof ret !== "function") { + if (!isIdentifier(name)) { + return null; + } + ret = compiler(name); + cache[name] = ret; + cache[" size"]++; + if (cache[" size"] > 512) { + var keys = Object.keys(cache); + for (var i = 0; i < 256; ++i) delete cache[keys[i]]; + cache[" size"] = keys.length - 256; + } + } + return ret; +}; + +getMethodCaller = function(name) { + return getCompiled(name, makeMethodCaller, callerCache); +}; + +getGetter = function(name) { + return getCompiled(name, makeGetter, getterCache); +}; +} + +function ensureMethod(obj, methodName) { + var fn; + if (obj != null) fn = obj[methodName]; + if (typeof fn !== "function") { + var message = "Object " + util.classString(obj) + " has no method '" + + util.toString(methodName) + "'"; + throw new Promise.TypeError(message); + } + return fn; +} + +function caller(obj) { + var methodName = this.pop(); + var fn = ensureMethod(obj, methodName); + return fn.apply(obj, this); +} +Promise.prototype.call = function (methodName) { + var args = [].slice.call(arguments, 1);; + if (!true) { + if (canEvaluate) { + var maybeCaller = getMethodCaller(methodName); + if (maybeCaller !== null) { + return this._then( + maybeCaller, undefined, undefined, args, undefined); + } + } + } + args.push(methodName); + return this._then(caller, undefined, undefined, args, undefined); +}; + +function namedGetter(obj) { + return obj[this]; +} +function indexedGetter(obj) { + var index = +this; + if (index < 0) index = Math.max(0, index + obj.length); + return obj[index]; +} +Promise.prototype.get = function (propertyName) { + var isIndex = (typeof propertyName === "number"); + var getter; + if (!isIndex) { + if (canEvaluate) { + var maybeGetter = getGetter(propertyName); + getter = maybeGetter !== null ? maybeGetter : namedGetter; + } else { + getter = namedGetter; + } + } else { + getter = indexedGetter; + } + return this._then(getter, undefined, undefined, propertyName, undefined); +}; +}; + +},{"./util":36}],6:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, PromiseArray, apiRejection, debug) { +var util = _dereq_("./util"); +var tryCatch = util.tryCatch; +var errorObj = util.errorObj; +var async = Promise._async; + +Promise.prototype["break"] = Promise.prototype.cancel = function() { + if (!debug.cancellation()) return this._warn("cancellation is disabled"); + + var promise = this; + var child = promise; + while (promise._isCancellable()) { + if (!promise._cancelBy(child)) { + if (child._isFollowing()) { + child._followee().cancel(); + } else { + child._cancelBranched(); + } + break; + } + + var parent = promise._cancellationParent; + if (parent == null || !parent._isCancellable()) { + if (promise._isFollowing()) { + promise._followee().cancel(); + } else { + promise._cancelBranched(); + } + break; + } else { + if (promise._isFollowing()) promise._followee().cancel(); + promise._setWillBeCancelled(); + child = promise; + promise = parent; + } + } +}; + +Promise.prototype._branchHasCancelled = function() { + this._branchesRemainingToCancel--; +}; + +Promise.prototype._enoughBranchesHaveCancelled = function() { + return this._branchesRemainingToCancel === undefined || + this._branchesRemainingToCancel <= 0; +}; + +Promise.prototype._cancelBy = function(canceller) { + if (canceller === this) { + this._branchesRemainingToCancel = 0; + this._invokeOnCancel(); + return true; + } else { + this._branchHasCancelled(); + if (this._enoughBranchesHaveCancelled()) { + this._invokeOnCancel(); + return true; + } + } + return false; +}; + +Promise.prototype._cancelBranched = function() { + if (this._enoughBranchesHaveCancelled()) { + this._cancel(); + } +}; + +Promise.prototype._cancel = function() { + if (!this._isCancellable()) return; + this._setCancelled(); + async.invoke(this._cancelPromises, this, undefined); +}; + +Promise.prototype._cancelPromises = function() { + if (this._length() > 0) this._settlePromises(); +}; + +Promise.prototype._unsetOnCancel = function() { + this._onCancelField = undefined; +}; + +Promise.prototype._isCancellable = function() { + return this.isPending() && !this._isCancelled(); +}; + +Promise.prototype.isCancellable = function() { + return this.isPending() && !this.isCancelled(); +}; + +Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) { + if (util.isArray(onCancelCallback)) { + for (var i = 0; i < onCancelCallback.length; ++i) { + this._doInvokeOnCancel(onCancelCallback[i], internalOnly); + } + } else if (onCancelCallback !== undefined) { + if (typeof onCancelCallback === "function") { + if (!internalOnly) { + var e = tryCatch(onCancelCallback).call(this._boundValue()); + if (e === errorObj) { + this._attachExtraTrace(e.e); + async.throwLater(e.e); + } + } + } else { + onCancelCallback._resultCancelled(this); + } + } +}; + +Promise.prototype._invokeOnCancel = function() { + var onCancelCallback = this._onCancel(); + this._unsetOnCancel(); + async.invoke(this._doInvokeOnCancel, this, onCancelCallback); +}; + +Promise.prototype._invokeInternalOnCancel = function() { + if (this._isCancellable()) { + this._doInvokeOnCancel(this._onCancel(), true); + this._unsetOnCancel(); + } +}; + +Promise.prototype._resultCancelled = function() { + this.cancel(); +}; + +}; + +},{"./util":36}],7:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(NEXT_FILTER) { +var util = _dereq_("./util"); +var getKeys = _dereq_("./es5").keys; +var tryCatch = util.tryCatch; +var errorObj = util.errorObj; + +function catchFilter(instances, cb, promise) { + return function(e) { + var boundTo = promise._boundValue(); + predicateLoop: for (var i = 0; i < instances.length; ++i) { + var item = instances[i]; + + if (item === Error || + (item != null && item.prototype instanceof Error)) { + if (e instanceof item) { + return tryCatch(cb).call(boundTo, e); + } + } else if (typeof item === "function") { + var matchesPredicate = tryCatch(item).call(boundTo, e); + if (matchesPredicate === errorObj) { + return matchesPredicate; + } else if (matchesPredicate) { + return tryCatch(cb).call(boundTo, e); + } + } else if (util.isObject(e)) { + var keys = getKeys(item); + for (var j = 0; j < keys.length; ++j) { + var key = keys[j]; + if (item[key] != e[key]) { + continue predicateLoop; + } + } + return tryCatch(cb).call(boundTo, e); + } + } + return NEXT_FILTER; + }; +} + +return catchFilter; +}; + +},{"./es5":13,"./util":36}],8:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise) { +var longStackTraces = false; +var contextStack = []; + +Promise.prototype._promiseCreated = function() {}; +Promise.prototype._pushContext = function() {}; +Promise.prototype._popContext = function() {return null;}; +Promise._peekContext = Promise.prototype._peekContext = function() {}; + +function Context() { + this._trace = new Context.CapturedTrace(peekContext()); +} +Context.prototype._pushContext = function () { + if (this._trace !== undefined) { + this._trace._promiseCreated = null; + contextStack.push(this._trace); + } +}; + +Context.prototype._popContext = function () { + if (this._trace !== undefined) { + var trace = contextStack.pop(); + var ret = trace._promiseCreated; + trace._promiseCreated = null; + return ret; + } + return null; +}; + +function createContext() { + if (longStackTraces) return new Context(); +} + +function peekContext() { + var lastIndex = contextStack.length - 1; + if (lastIndex >= 0) { + return contextStack[lastIndex]; + } + return undefined; +} +Context.CapturedTrace = null; +Context.create = createContext; +Context.deactivateLongStackTraces = function() {}; +Context.activateLongStackTraces = function() { + var Promise_pushContext = Promise.prototype._pushContext; + var Promise_popContext = Promise.prototype._popContext; + var Promise_PeekContext = Promise._peekContext; + var Promise_peekContext = Promise.prototype._peekContext; + var Promise_promiseCreated = Promise.prototype._promiseCreated; + Context.deactivateLongStackTraces = function() { + Promise.prototype._pushContext = Promise_pushContext; + Promise.prototype._popContext = Promise_popContext; + Promise._peekContext = Promise_PeekContext; + Promise.prototype._peekContext = Promise_peekContext; + Promise.prototype._promiseCreated = Promise_promiseCreated; + longStackTraces = false; + }; + longStackTraces = true; + Promise.prototype._pushContext = Context.prototype._pushContext; + Promise.prototype._popContext = Context.prototype._popContext; + Promise._peekContext = Promise.prototype._peekContext = peekContext; + Promise.prototype._promiseCreated = function() { + var ctx = this._peekContext(); + if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this; + }; +}; +return Context; +}; + +},{}],9:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, Context) { +var getDomain = Promise._getDomain; +var async = Promise._async; +var Warning = _dereq_("./errors").Warning; +var util = _dereq_("./util"); +var es5 = _dereq_("./es5"); +var canAttachTrace = util.canAttachTrace; +var unhandledRejectionHandled; +var possiblyUnhandledRejection; +var bluebirdFramePattern = + /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/; +var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/; +var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/; +var stackFramePattern = null; +var formatStack = null; +var indentStackFrames = false; +var printWarning; +var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 && + (true || + util.env("BLUEBIRD_DEBUG") || + util.env("NODE_ENV") === "development")); + +var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 && + (debugging || util.env("BLUEBIRD_WARNINGS"))); + +var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 && + (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES"))); + +var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 && + (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN")); + +Promise.prototype.suppressUnhandledRejections = function() { + var target = this._target(); + target._bitField = ((target._bitField & (~1048576)) | + 524288); +}; + +Promise.prototype._ensurePossibleRejectionHandled = function () { + if ((this._bitField & 524288) !== 0) return; + this._setRejectionIsUnhandled(); + var self = this; + setTimeout(function() { + self._notifyUnhandledRejection(); + }, 1); +}; + +Promise.prototype._notifyUnhandledRejectionIsHandled = function () { + fireRejectionEvent("rejectionHandled", + unhandledRejectionHandled, undefined, this); +}; + +Promise.prototype._setReturnedNonUndefined = function() { + this._bitField = this._bitField | 268435456; +}; + +Promise.prototype._returnedNonUndefined = function() { + return (this._bitField & 268435456) !== 0; +}; + +Promise.prototype._notifyUnhandledRejection = function () { + if (this._isRejectionUnhandled()) { + var reason = this._settledValue(); + this._setUnhandledRejectionIsNotified(); + fireRejectionEvent("unhandledRejection", + possiblyUnhandledRejection, reason, this); + } +}; + +Promise.prototype._setUnhandledRejectionIsNotified = function () { + this._bitField = this._bitField | 262144; +}; + +Promise.prototype._unsetUnhandledRejectionIsNotified = function () { + this._bitField = this._bitField & (~262144); +}; + +Promise.prototype._isUnhandledRejectionNotified = function () { + return (this._bitField & 262144) > 0; +}; + +Promise.prototype._setRejectionIsUnhandled = function () { + this._bitField = this._bitField | 1048576; +}; + +Promise.prototype._unsetRejectionIsUnhandled = function () { + this._bitField = this._bitField & (~1048576); + if (this._isUnhandledRejectionNotified()) { + this._unsetUnhandledRejectionIsNotified(); + this._notifyUnhandledRejectionIsHandled(); + } +}; + +Promise.prototype._isRejectionUnhandled = function () { + return (this._bitField & 1048576) > 0; +}; + +Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) { + return warn(message, shouldUseOwnTrace, promise || this); +}; + +Promise.onPossiblyUnhandledRejection = function (fn) { + var domain = getDomain(); + possiblyUnhandledRejection = + typeof fn === "function" ? (domain === null ? + fn : util.domainBind(domain, fn)) + : undefined; +}; + +Promise.onUnhandledRejectionHandled = function (fn) { + var domain = getDomain(); + unhandledRejectionHandled = + typeof fn === "function" ? (domain === null ? + fn : util.domainBind(domain, fn)) + : undefined; +}; + +var disableLongStackTraces = function() {}; +Promise.longStackTraces = function () { + if (async.haveItemsQueued() && !config.longStackTraces) { + throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + if (!config.longStackTraces && longStackTracesIsSupported()) { + var Promise_captureStackTrace = Promise.prototype._captureStackTrace; + var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace; + var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace; + config.longStackTraces = true; + disableLongStackTraces = function() { + if (async.haveItemsQueued() && !config.longStackTraces) { + throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + Promise.prototype._captureStackTrace = Promise_captureStackTrace; + Promise.prototype._attachExtraTrace = Promise_attachExtraTrace; + Promise.prototype._dereferenceTrace = Promise_dereferenceTrace; + Context.deactivateLongStackTraces(); + async.enableTrampoline(); + config.longStackTraces = false; + }; + Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace; + Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace; + Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace; + Context.activateLongStackTraces(); + async.disableTrampolineIfNecessary(); + } +}; + +Promise.hasLongStackTraces = function () { + return config.longStackTraces && longStackTracesIsSupported(); +}; + +var fireDomEvent = (function() { + try { + if (typeof CustomEvent === "function") { + var event = new CustomEvent("CustomEvent"); + util.global.dispatchEvent(event); + return function(name, event) { + var eventData = { + detail: event, + cancelable: true + }; + es5.defineProperty( + eventData, "promise", {value: event.promise}); + es5.defineProperty(eventData, "reason", {value: event.reason}); + var domEvent = new CustomEvent(name.toLowerCase(), eventData); + return !util.global.dispatchEvent(domEvent); + }; + } else if (typeof Event === "function") { + var event = new Event("CustomEvent"); + util.global.dispatchEvent(event); + return function(name, event) { + var domEvent = new Event(name.toLowerCase(), { + cancelable: true + }); + domEvent.detail = event; + es5.defineProperty(domEvent, "promise", {value: event.promise}); + es5.defineProperty(domEvent, "reason", {value: event.reason}); + return !util.global.dispatchEvent(domEvent); + }; + } else { + var event = document.createEvent("CustomEvent"); + event.initCustomEvent("testingtheevent", false, true, {}); + util.global.dispatchEvent(event); + return function(name, event) { + var domEvent = document.createEvent("CustomEvent"); + domEvent.initCustomEvent(name.toLowerCase(), false, true, + event); + return !util.global.dispatchEvent(domEvent); + }; + } + } catch (e) {} + return function() { + return false; + }; +})(); + +var fireGlobalEvent = (function() { + if (util.isNode) { + return function() { + return process.emit.apply(process, arguments); + }; + } else { + if (!util.global) { + return function() { + return false; + }; + } + return function(name) { + var methodName = "on" + name.toLowerCase(); + var method = util.global[methodName]; + if (!method) return false; + method.apply(util.global, [].slice.call(arguments, 1)); + return true; + }; + } +})(); + +function generatePromiseLifecycleEventObject(name, promise) { + return {promise: promise}; +} + +var eventToObjectGenerator = { + promiseCreated: generatePromiseLifecycleEventObject, + promiseFulfilled: generatePromiseLifecycleEventObject, + promiseRejected: generatePromiseLifecycleEventObject, + promiseResolved: generatePromiseLifecycleEventObject, + promiseCancelled: generatePromiseLifecycleEventObject, + promiseChained: function(name, promise, child) { + return {promise: promise, child: child}; + }, + warning: function(name, warning) { + return {warning: warning}; + }, + unhandledRejection: function (name, reason, promise) { + return {reason: reason, promise: promise}; + }, + rejectionHandled: generatePromiseLifecycleEventObject +}; + +var activeFireEvent = function (name) { + var globalEventFired = false; + try { + globalEventFired = fireGlobalEvent.apply(null, arguments); + } catch (e) { + async.throwLater(e); + globalEventFired = true; + } + + var domEventFired = false; + try { + domEventFired = fireDomEvent(name, + eventToObjectGenerator[name].apply(null, arguments)); + } catch (e) { + async.throwLater(e); + domEventFired = true; + } + + return domEventFired || globalEventFired; +}; + +Promise.config = function(opts) { + opts = Object(opts); + if ("longStackTraces" in opts) { + if (opts.longStackTraces) { + Promise.longStackTraces(); + } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) { + disableLongStackTraces(); + } + } + if ("warnings" in opts) { + var warningsOption = opts.warnings; + config.warnings = !!warningsOption; + wForgottenReturn = config.warnings; + + if (util.isObject(warningsOption)) { + if ("wForgottenReturn" in warningsOption) { + wForgottenReturn = !!warningsOption.wForgottenReturn; + } + } + } + if ("cancellation" in opts && opts.cancellation && !config.cancellation) { + if (async.haveItemsQueued()) { + throw new Error( + "cannot enable cancellation after promises are in use"); + } + Promise.prototype._clearCancellationData = + cancellationClearCancellationData; + Promise.prototype._propagateFrom = cancellationPropagateFrom; + Promise.prototype._onCancel = cancellationOnCancel; + Promise.prototype._setOnCancel = cancellationSetOnCancel; + Promise.prototype._attachCancellationCallback = + cancellationAttachCancellationCallback; + Promise.prototype._execute = cancellationExecute; + propagateFromFunction = cancellationPropagateFrom; + config.cancellation = true; + } + if ("monitoring" in opts) { + if (opts.monitoring && !config.monitoring) { + config.monitoring = true; + Promise.prototype._fireEvent = activeFireEvent; + } else if (!opts.monitoring && config.monitoring) { + config.monitoring = false; + Promise.prototype._fireEvent = defaultFireEvent; + } + } + return Promise; +}; + +function defaultFireEvent() { return false; } + +Promise.prototype._fireEvent = defaultFireEvent; +Promise.prototype._execute = function(executor, resolve, reject) { + try { + executor(resolve, reject); + } catch (e) { + return e; + } +}; +Promise.prototype._onCancel = function () {}; +Promise.prototype._setOnCancel = function (handler) { ; }; +Promise.prototype._attachCancellationCallback = function(onCancel) { + ; +}; +Promise.prototype._captureStackTrace = function () {}; +Promise.prototype._attachExtraTrace = function () {}; +Promise.prototype._dereferenceTrace = function () {}; +Promise.prototype._clearCancellationData = function() {}; +Promise.prototype._propagateFrom = function (parent, flags) { + ; + ; +}; + +function cancellationExecute(executor, resolve, reject) { + var promise = this; + try { + executor(resolve, reject, function(onCancel) { + if (typeof onCancel !== "function") { + throw new TypeError("onCancel must be a function, got: " + + util.toString(onCancel)); + } + promise._attachCancellationCallback(onCancel); + }); + } catch (e) { + return e; + } +} + +function cancellationAttachCancellationCallback(onCancel) { + if (!this._isCancellable()) return this; + + var previousOnCancel = this._onCancel(); + if (previousOnCancel !== undefined) { + if (util.isArray(previousOnCancel)) { + previousOnCancel.push(onCancel); + } else { + this._setOnCancel([previousOnCancel, onCancel]); + } + } else { + this._setOnCancel(onCancel); + } +} + +function cancellationOnCancel() { + return this._onCancelField; +} + +function cancellationSetOnCancel(onCancel) { + this._onCancelField = onCancel; +} + +function cancellationClearCancellationData() { + this._cancellationParent = undefined; + this._onCancelField = undefined; +} + +function cancellationPropagateFrom(parent, flags) { + if ((flags & 1) !== 0) { + this._cancellationParent = parent; + var branchesRemainingToCancel = parent._branchesRemainingToCancel; + if (branchesRemainingToCancel === undefined) { + branchesRemainingToCancel = 0; + } + parent._branchesRemainingToCancel = branchesRemainingToCancel + 1; + } + if ((flags & 2) !== 0 && parent._isBound()) { + this._setBoundTo(parent._boundTo); + } +} + +function bindingPropagateFrom(parent, flags) { + if ((flags & 2) !== 0 && parent._isBound()) { + this._setBoundTo(parent._boundTo); + } +} +var propagateFromFunction = bindingPropagateFrom; + +function boundValueFunction() { + var ret = this._boundTo; + if (ret !== undefined) { + if (ret instanceof Promise) { + if (ret.isFulfilled()) { + return ret.value(); + } else { + return undefined; + } + } + } + return ret; +} + +function longStackTracesCaptureStackTrace() { + this._trace = new CapturedTrace(this._peekContext()); +} + +function longStackTracesAttachExtraTrace(error, ignoreSelf) { + if (canAttachTrace(error)) { + var trace = this._trace; + if (trace !== undefined) { + if (ignoreSelf) trace = trace._parent; + } + if (trace !== undefined) { + trace.attachExtraTrace(error); + } else if (!error.__stackCleaned__) { + var parsed = parseStackAndMessage(error); + util.notEnumerableProp(error, "stack", + parsed.message + "\n" + parsed.stack.join("\n")); + util.notEnumerableProp(error, "__stackCleaned__", true); + } + } +} + +function longStackTracesDereferenceTrace() { + this._trace = undefined; +} + +function checkForgottenReturns(returnValue, promiseCreated, name, promise, + parent) { + if (returnValue === undefined && promiseCreated !== null && + wForgottenReturn) { + if (parent !== undefined && parent._returnedNonUndefined()) return; + if ((promise._bitField & 65535) === 0) return; + + if (name) name = name + " "; + var handlerLine = ""; + var creatorLine = ""; + if (promiseCreated._trace) { + var traceLines = promiseCreated._trace.stack.split("\n"); + var stack = cleanStack(traceLines); + for (var i = stack.length - 1; i >= 0; --i) { + var line = stack[i]; + if (!nodeFramePattern.test(line)) { + var lineMatches = line.match(parseLinePattern); + if (lineMatches) { + handlerLine = "at " + lineMatches[1] + + ":" + lineMatches[2] + ":" + lineMatches[3] + " "; + } + break; + } + } + + if (stack.length > 0) { + var firstUserLine = stack[0]; + for (var i = 0; i < traceLines.length; ++i) { + + if (traceLines[i] === firstUserLine) { + if (i > 0) { + creatorLine = "\n" + traceLines[i - 1]; + } + break; + } + } + + } + } + var msg = "a promise was created in a " + name + + "handler " + handlerLine + "but was not returned from it, " + + "see http://goo.gl/rRqMUw" + + creatorLine; + promise._warn(msg, true, promiseCreated); + } +} + +function deprecated(name, replacement) { + var message = name + + " is deprecated and will be removed in a future version."; + if (replacement) message += " Use " + replacement + " instead."; + return warn(message); +} + +function warn(message, shouldUseOwnTrace, promise) { + if (!config.warnings) return; + var warning = new Warning(message); + var ctx; + if (shouldUseOwnTrace) { + promise._attachExtraTrace(warning); + } else if (config.longStackTraces && (ctx = Promise._peekContext())) { + ctx.attachExtraTrace(warning); + } else { + var parsed = parseStackAndMessage(warning); + warning.stack = parsed.message + "\n" + parsed.stack.join("\n"); + } + + if (!activeFireEvent("warning", warning)) { + formatAndLogError(warning, "", true); + } +} + +function reconstructStack(message, stacks) { + for (var i = 0; i < stacks.length - 1; ++i) { + stacks[i].push("From previous event:"); + stacks[i] = stacks[i].join("\n"); + } + if (i < stacks.length) { + stacks[i] = stacks[i].join("\n"); + } + return message + "\n" + stacks.join("\n"); +} + +function removeDuplicateOrEmptyJumps(stacks) { + for (var i = 0; i < stacks.length; ++i) { + if (stacks[i].length === 0 || + ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) { + stacks.splice(i, 1); + i--; + } + } +} + +function removeCommonRoots(stacks) { + var current = stacks[0]; + for (var i = 1; i < stacks.length; ++i) { + var prev = stacks[i]; + var currentLastIndex = current.length - 1; + var currentLastLine = current[currentLastIndex]; + var commonRootMeetPoint = -1; + + for (var j = prev.length - 1; j >= 0; --j) { + if (prev[j] === currentLastLine) { + commonRootMeetPoint = j; + break; + } + } + + for (var j = commonRootMeetPoint; j >= 0; --j) { + var line = prev[j]; + if (current[currentLastIndex] === line) { + current.pop(); + currentLastIndex--; + } else { + break; + } + } + current = prev; + } +} + +function cleanStack(stack) { + var ret = []; + for (var i = 0; i < stack.length; ++i) { + var line = stack[i]; + var isTraceLine = " (No stack trace)" === line || + stackFramePattern.test(line); + var isInternalFrame = isTraceLine && shouldIgnore(line); + if (isTraceLine && !isInternalFrame) { + if (indentStackFrames && line.charAt(0) !== " ") { + line = " " + line; + } + ret.push(line); + } + } + return ret; +} + +function stackFramesAsArray(error) { + var stack = error.stack.replace(/\s+$/g, "").split("\n"); + for (var i = 0; i < stack.length; ++i) { + var line = stack[i]; + if (" (No stack trace)" === line || stackFramePattern.test(line)) { + break; + } + } + if (i > 0 && error.name != "SyntaxError") { + stack = stack.slice(i); + } + return stack; +} + +function parseStackAndMessage(error) { + var stack = error.stack; + var message = error.toString(); + stack = typeof stack === "string" && stack.length > 0 + ? stackFramesAsArray(error) : [" (No stack trace)"]; + return { + message: message, + stack: error.name == "SyntaxError" ? stack : cleanStack(stack) + }; +} + +function formatAndLogError(error, title, isSoft) { + if (typeof console !== "undefined") { + var message; + if (util.isObject(error)) { + var stack = error.stack; + message = title + formatStack(stack, error); + } else { + message = title + String(error); + } + if (typeof printWarning === "function") { + printWarning(message, isSoft); + } else if (typeof console.log === "function" || + typeof console.log === "object") { + console.log(message); + } + } +} + +function fireRejectionEvent(name, localHandler, reason, promise) { + var localEventFired = false; + try { + if (typeof localHandler === "function") { + localEventFired = true; + if (name === "rejectionHandled") { + localHandler(promise); + } else { + localHandler(reason, promise); + } + } + } catch (e) { + async.throwLater(e); + } + + if (name === "unhandledRejection") { + if (!activeFireEvent(name, reason, promise) && !localEventFired) { + formatAndLogError(reason, "Unhandled rejection "); + } + } else { + activeFireEvent(name, promise); + } +} + +function formatNonError(obj) { + var str; + if (typeof obj === "function") { + str = "[function " + + (obj.name || "anonymous") + + "]"; + } else { + str = obj && typeof obj.toString === "function" + ? obj.toString() : util.toString(obj); + var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/; + if (ruselessToString.test(str)) { + try { + var newStr = JSON.stringify(obj); + str = newStr; + } + catch(e) { + + } + } + if (str.length === 0) { + str = "(empty array)"; + } + } + return ("(<" + snip(str) + ">, no stack trace)"); +} + +function snip(str) { + var maxChars = 41; + if (str.length < maxChars) { + return str; + } + return str.substr(0, maxChars - 3) + "..."; +} + +function longStackTracesIsSupported() { + return typeof captureStackTrace === "function"; +} + +var shouldIgnore = function() { return false; }; +var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/; +function parseLineInfo(line) { + var matches = line.match(parseLineInfoRegex); + if (matches) { + return { + fileName: matches[1], + line: parseInt(matches[2], 10) + }; + } +} + +function setBounds(firstLineError, lastLineError) { + if (!longStackTracesIsSupported()) return; + var firstStackLines = firstLineError.stack.split("\n"); + var lastStackLines = lastLineError.stack.split("\n"); + var firstIndex = -1; + var lastIndex = -1; + var firstFileName; + var lastFileName; + for (var i = 0; i < firstStackLines.length; ++i) { + var result = parseLineInfo(firstStackLines[i]); + if (result) { + firstFileName = result.fileName; + firstIndex = result.line; + break; + } + } + for (var i = 0; i < lastStackLines.length; ++i) { + var result = parseLineInfo(lastStackLines[i]); + if (result) { + lastFileName = result.fileName; + lastIndex = result.line; + break; + } + } + if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName || + firstFileName !== lastFileName || firstIndex >= lastIndex) { + return; + } + + shouldIgnore = function(line) { + if (bluebirdFramePattern.test(line)) return true; + var info = parseLineInfo(line); + if (info) { + if (info.fileName === firstFileName && + (firstIndex <= info.line && info.line <= lastIndex)) { + return true; + } + } + return false; + }; +} + +function CapturedTrace(parent) { + this._parent = parent; + this._promisesCreated = 0; + var length = this._length = 1 + (parent === undefined ? 0 : parent._length); + captureStackTrace(this, CapturedTrace); + if (length > 32) this.uncycle(); +} +util.inherits(CapturedTrace, Error); +Context.CapturedTrace = CapturedTrace; + +CapturedTrace.prototype.uncycle = function() { + var length = this._length; + if (length < 2) return; + var nodes = []; + var stackToIndex = {}; + + for (var i = 0, node = this; node !== undefined; ++i) { + nodes.push(node); + node = node._parent; + } + length = this._length = i; + for (var i = length - 1; i >= 0; --i) { + var stack = nodes[i].stack; + if (stackToIndex[stack] === undefined) { + stackToIndex[stack] = i; + } + } + for (var i = 0; i < length; ++i) { + var currentStack = nodes[i].stack; + var index = stackToIndex[currentStack]; + if (index !== undefined && index !== i) { + if (index > 0) { + nodes[index - 1]._parent = undefined; + nodes[index - 1]._length = 1; + } + nodes[i]._parent = undefined; + nodes[i]._length = 1; + var cycleEdgeNode = i > 0 ? nodes[i - 1] : this; + + if (index < length - 1) { + cycleEdgeNode._parent = nodes[index + 1]; + cycleEdgeNode._parent.uncycle(); + cycleEdgeNode._length = + cycleEdgeNode._parent._length + 1; + } else { + cycleEdgeNode._parent = undefined; + cycleEdgeNode._length = 1; + } + var currentChildLength = cycleEdgeNode._length + 1; + for (var j = i - 2; j >= 0; --j) { + nodes[j]._length = currentChildLength; + currentChildLength++; + } + return; + } + } +}; + +CapturedTrace.prototype.attachExtraTrace = function(error) { + if (error.__stackCleaned__) return; + this.uncycle(); + var parsed = parseStackAndMessage(error); + var message = parsed.message; + var stacks = [parsed.stack]; + + var trace = this; + while (trace !== undefined) { + stacks.push(cleanStack(trace.stack.split("\n"))); + trace = trace._parent; + } + removeCommonRoots(stacks); + removeDuplicateOrEmptyJumps(stacks); + util.notEnumerableProp(error, "stack", reconstructStack(message, stacks)); + util.notEnumerableProp(error, "__stackCleaned__", true); +}; + +var captureStackTrace = (function stackDetection() { + var v8stackFramePattern = /^\s*at\s*/; + var v8stackFormatter = function(stack, error) { + if (typeof stack === "string") return stack; + + if (error.name !== undefined && + error.message !== undefined) { + return error.toString(); + } + return formatNonError(error); + }; + + if (typeof Error.stackTraceLimit === "number" && + typeof Error.captureStackTrace === "function") { + Error.stackTraceLimit += 6; + stackFramePattern = v8stackFramePattern; + formatStack = v8stackFormatter; + var captureStackTrace = Error.captureStackTrace; + + shouldIgnore = function(line) { + return bluebirdFramePattern.test(line); + }; + return function(receiver, ignoreUntil) { + Error.stackTraceLimit += 6; + captureStackTrace(receiver, ignoreUntil); + Error.stackTraceLimit -= 6; + }; + } + var err = new Error(); + + if (typeof err.stack === "string" && + err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) { + stackFramePattern = /@/; + formatStack = v8stackFormatter; + indentStackFrames = true; + return function captureStackTrace(o) { + o.stack = new Error().stack; + }; + } + + var hasStackAfterThrow; + try { throw new Error(); } + catch(e) { + hasStackAfterThrow = ("stack" in e); + } + if (!("stack" in err) && hasStackAfterThrow && + typeof Error.stackTraceLimit === "number") { + stackFramePattern = v8stackFramePattern; + formatStack = v8stackFormatter; + return function captureStackTrace(o) { + Error.stackTraceLimit += 6; + try { throw new Error(); } + catch(e) { o.stack = e.stack; } + Error.stackTraceLimit -= 6; + }; + } + + formatStack = function(stack, error) { + if (typeof stack === "string") return stack; + + if ((typeof error === "object" || + typeof error === "function") && + error.name !== undefined && + error.message !== undefined) { + return error.toString(); + } + return formatNonError(error); + }; + + return null; + +})([]); + +if (typeof console !== "undefined" && typeof console.warn !== "undefined") { + printWarning = function (message) { + console.warn(message); + }; + if (util.isNode && process.stderr.isTTY) { + printWarning = function(message, isSoft) { + var color = isSoft ? "\u001b[33m" : "\u001b[31m"; + console.warn(color + message + "\u001b[0m\n"); + }; + } else if (!util.isNode && typeof (new Error().stack) === "string") { + printWarning = function(message, isSoft) { + console.warn("%c" + message, + isSoft ? "color: darkorange" : "color: red"); + }; + } +} + +var config = { + warnings: warnings, + longStackTraces: false, + cancellation: false, + monitoring: false +}; + +if (longStackTraces) Promise.longStackTraces(); + +return { + longStackTraces: function() { + return config.longStackTraces; + }, + warnings: function() { + return config.warnings; + }, + cancellation: function() { + return config.cancellation; + }, + monitoring: function() { + return config.monitoring; + }, + propagateFromFunction: function() { + return propagateFromFunction; + }, + boundValueFunction: function() { + return boundValueFunction; + }, + checkForgottenReturns: checkForgottenReturns, + setBounds: setBounds, + warn: warn, + deprecated: deprecated, + CapturedTrace: CapturedTrace, + fireDomEvent: fireDomEvent, + fireGlobalEvent: fireGlobalEvent +}; +}; + +},{"./errors":12,"./es5":13,"./util":36}],10:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise) { +function returner() { + return this.value; +} +function thrower() { + throw this.reason; +} + +Promise.prototype["return"] = +Promise.prototype.thenReturn = function (value) { + if (value instanceof Promise) value.suppressUnhandledRejections(); + return this._then( + returner, undefined, undefined, {value: value}, undefined); +}; + +Promise.prototype["throw"] = +Promise.prototype.thenThrow = function (reason) { + return this._then( + thrower, undefined, undefined, {reason: reason}, undefined); +}; + +Promise.prototype.catchThrow = function (reason) { + if (arguments.length <= 1) { + return this._then( + undefined, thrower, undefined, {reason: reason}, undefined); + } else { + var _reason = arguments[1]; + var handler = function() {throw _reason;}; + return this.caught(reason, handler); + } +}; + +Promise.prototype.catchReturn = function (value) { + if (arguments.length <= 1) { + if (value instanceof Promise) value.suppressUnhandledRejections(); + return this._then( + undefined, returner, undefined, {value: value}, undefined); + } else { + var _value = arguments[1]; + if (_value instanceof Promise) _value.suppressUnhandledRejections(); + var handler = function() {return _value;}; + return this.caught(value, handler); + } +}; +}; + +},{}],11:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL) { +var PromiseReduce = Promise.reduce; +var PromiseAll = Promise.all; + +function promiseAllThis() { + return PromiseAll(this); +} + +function PromiseMapSeries(promises, fn) { + return PromiseReduce(promises, fn, INTERNAL, INTERNAL); +} + +Promise.prototype.each = function (fn) { + return PromiseReduce(this, fn, INTERNAL, 0) + ._then(promiseAllThis, undefined, undefined, this, undefined); +}; + +Promise.prototype.mapSeries = function (fn) { + return PromiseReduce(this, fn, INTERNAL, INTERNAL); +}; + +Promise.each = function (promises, fn) { + return PromiseReduce(promises, fn, INTERNAL, 0) + ._then(promiseAllThis, undefined, undefined, promises, undefined); +}; + +Promise.mapSeries = PromiseMapSeries; +}; + + +},{}],12:[function(_dereq_,module,exports){ +"use strict"; +var es5 = _dereq_("./es5"); +var Objectfreeze = es5.freeze; +var util = _dereq_("./util"); +var inherits = util.inherits; +var notEnumerableProp = util.notEnumerableProp; + +function subError(nameProperty, defaultMessage) { + function SubError(message) { + if (!(this instanceof SubError)) return new SubError(message); + notEnumerableProp(this, "message", + typeof message === "string" ? message : defaultMessage); + notEnumerableProp(this, "name", nameProperty); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } else { + Error.call(this); + } + } + inherits(SubError, Error); + return SubError; +} + +var _TypeError, _RangeError; +var Warning = subError("Warning", "warning"); +var CancellationError = subError("CancellationError", "cancellation error"); +var TimeoutError = subError("TimeoutError", "timeout error"); +var AggregateError = subError("AggregateError", "aggregate error"); +try { + _TypeError = TypeError; + _RangeError = RangeError; +} catch(e) { + _TypeError = subError("TypeError", "type error"); + _RangeError = subError("RangeError", "range error"); +} + +var methods = ("join pop push shift unshift slice filter forEach some " + + "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" "); + +for (var i = 0; i < methods.length; ++i) { + if (typeof Array.prototype[methods[i]] === "function") { + AggregateError.prototype[methods[i]] = Array.prototype[methods[i]]; + } +} + +es5.defineProperty(AggregateError.prototype, "length", { + value: 0, + configurable: false, + writable: true, + enumerable: true +}); +AggregateError.prototype["isOperational"] = true; +var level = 0; +AggregateError.prototype.toString = function() { + var indent = Array(level * 4 + 1).join(" "); + var ret = "\n" + indent + "AggregateError of:" + "\n"; + level++; + indent = Array(level * 4 + 1).join(" "); + for (var i = 0; i < this.length; ++i) { + var str = this[i] === this ? "[Circular AggregateError]" : this[i] + ""; + var lines = str.split("\n"); + for (var j = 0; j < lines.length; ++j) { + lines[j] = indent + lines[j]; + } + str = lines.join("\n"); + ret += str + "\n"; + } + level--; + return ret; +}; + +function OperationalError(message) { + if (!(this instanceof OperationalError)) + return new OperationalError(message); + notEnumerableProp(this, "name", "OperationalError"); + notEnumerableProp(this, "message", message); + this.cause = message; + this["isOperational"] = true; + + if (message instanceof Error) { + notEnumerableProp(this, "message", message.message); + notEnumerableProp(this, "stack", message.stack); + } else if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + +} +inherits(OperationalError, Error); + +var errorTypes = Error["__BluebirdErrorTypes__"]; +if (!errorTypes) { + errorTypes = Objectfreeze({ + CancellationError: CancellationError, + TimeoutError: TimeoutError, + OperationalError: OperationalError, + RejectionError: OperationalError, + AggregateError: AggregateError + }); + es5.defineProperty(Error, "__BluebirdErrorTypes__", { + value: errorTypes, + writable: false, + enumerable: false, + configurable: false + }); +} + +module.exports = { + Error: Error, + TypeError: _TypeError, + RangeError: _RangeError, + CancellationError: errorTypes.CancellationError, + OperationalError: errorTypes.OperationalError, + TimeoutError: errorTypes.TimeoutError, + AggregateError: errorTypes.AggregateError, + Warning: Warning +}; + +},{"./es5":13,"./util":36}],13:[function(_dereq_,module,exports){ +var isES5 = (function(){ + "use strict"; + return this === undefined; +})(); + +if (isES5) { + module.exports = { + freeze: Object.freeze, + defineProperty: Object.defineProperty, + getDescriptor: Object.getOwnPropertyDescriptor, + keys: Object.keys, + names: Object.getOwnPropertyNames, + getPrototypeOf: Object.getPrototypeOf, + isArray: Array.isArray, + isES5: isES5, + propertyIsWritable: function(obj, prop) { + var descriptor = Object.getOwnPropertyDescriptor(obj, prop); + return !!(!descriptor || descriptor.writable || descriptor.set); + } + }; +} else { + var has = {}.hasOwnProperty; + var str = {}.toString; + var proto = {}.constructor.prototype; + + var ObjectKeys = function (o) { + var ret = []; + for (var key in o) { + if (has.call(o, key)) { + ret.push(key); + } + } + return ret; + }; + + var ObjectGetDescriptor = function(o, key) { + return {value: o[key]}; + }; + + var ObjectDefineProperty = function (o, key, desc) { + o[key] = desc.value; + return o; + }; + + var ObjectFreeze = function (obj) { + return obj; + }; + + var ObjectGetPrototypeOf = function (obj) { + try { + return Object(obj).constructor.prototype; + } + catch (e) { + return proto; + } + }; + + var ArrayIsArray = function (obj) { + try { + return str.call(obj) === "[object Array]"; + } + catch(e) { + return false; + } + }; + + module.exports = { + isArray: ArrayIsArray, + keys: ObjectKeys, + names: ObjectKeys, + defineProperty: ObjectDefineProperty, + getDescriptor: ObjectGetDescriptor, + freeze: ObjectFreeze, + getPrototypeOf: ObjectGetPrototypeOf, + isES5: isES5, + propertyIsWritable: function() { + return true; + } + }; +} + +},{}],14:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL) { +var PromiseMap = Promise.map; + +Promise.prototype.filter = function (fn, options) { + return PromiseMap(this, fn, options, INTERNAL); +}; + +Promise.filter = function (promises, fn, options) { + return PromiseMap(promises, fn, options, INTERNAL); +}; +}; + +},{}],15:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) { +var util = _dereq_("./util"); +var CancellationError = Promise.CancellationError; +var errorObj = util.errorObj; +var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER); + +function PassThroughHandlerContext(promise, type, handler) { + this.promise = promise; + this.type = type; + this.handler = handler; + this.called = false; + this.cancelPromise = null; +} + +PassThroughHandlerContext.prototype.isFinallyHandler = function() { + return this.type === 0; +}; + +function FinallyHandlerCancelReaction(finallyHandler) { + this.finallyHandler = finallyHandler; +} + +FinallyHandlerCancelReaction.prototype._resultCancelled = function() { + checkCancel(this.finallyHandler); +}; + +function checkCancel(ctx, reason) { + if (ctx.cancelPromise != null) { + if (arguments.length > 1) { + ctx.cancelPromise._reject(reason); + } else { + ctx.cancelPromise._cancel(); + } + ctx.cancelPromise = null; + return true; + } + return false; +} + +function succeed() { + return finallyHandler.call(this, this.promise._target()._settledValue()); +} +function fail(reason) { + if (checkCancel(this, reason)) return; + errorObj.e = reason; + return errorObj; +} +function finallyHandler(reasonOrValue) { + var promise = this.promise; + var handler = this.handler; + + if (!this.called) { + this.called = true; + var ret = this.isFinallyHandler() + ? handler.call(promise._boundValue()) + : handler.call(promise._boundValue(), reasonOrValue); + if (ret === NEXT_FILTER) { + return ret; + } else if (ret !== undefined) { + promise._setReturnedNonUndefined(); + var maybePromise = tryConvertToPromise(ret, promise); + if (maybePromise instanceof Promise) { + if (this.cancelPromise != null) { + if (maybePromise._isCancelled()) { + var reason = + new CancellationError("late cancellation observer"); + promise._attachExtraTrace(reason); + errorObj.e = reason; + return errorObj; + } else if (maybePromise.isPending()) { + maybePromise._attachCancellationCallback( + new FinallyHandlerCancelReaction(this)); + } + } + return maybePromise._then( + succeed, fail, undefined, this, undefined); + } + } + } + + if (promise.isRejected()) { + checkCancel(this); + errorObj.e = reasonOrValue; + return errorObj; + } else { + checkCancel(this); + return reasonOrValue; + } +} + +Promise.prototype._passThrough = function(handler, type, success, fail) { + if (typeof handler !== "function") return this.then(); + return this._then(success, + fail, + undefined, + new PassThroughHandlerContext(this, type, handler), + undefined); +}; + +Promise.prototype.lastly = +Promise.prototype["finally"] = function (handler) { + return this._passThrough(handler, + 0, + finallyHandler, + finallyHandler); +}; + + +Promise.prototype.tap = function (handler) { + return this._passThrough(handler, 1, finallyHandler); +}; + +Promise.prototype.tapCatch = function (handlerOrPredicate) { + var len = arguments.length; + if(len === 1) { + return this._passThrough(handlerOrPredicate, + 1, + undefined, + finallyHandler); + } else { + var catchInstances = new Array(len - 1), + j = 0, i; + for (i = 0; i < len - 1; ++i) { + var item = arguments[i]; + if (util.isObject(item)) { + catchInstances[j++] = item; + } else { + return Promise.reject(new TypeError( + "tapCatch statement predicate: " + + "expecting an object but got " + util.classString(item) + )); + } + } + catchInstances.length = j; + var handler = arguments[i]; + return this._passThrough(catchFilter(catchInstances, handler, this), + 1, + undefined, + finallyHandler); + } + +}; + +return PassThroughHandlerContext; +}; + +},{"./catch_filter":7,"./util":36}],16:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, + apiRejection, + INTERNAL, + tryConvertToPromise, + Proxyable, + debug) { +var errors = _dereq_("./errors"); +var TypeError = errors.TypeError; +var util = _dereq_("./util"); +var errorObj = util.errorObj; +var tryCatch = util.tryCatch; +var yieldHandlers = []; + +function promiseFromYieldHandler(value, yieldHandlers, traceParent) { + for (var i = 0; i < yieldHandlers.length; ++i) { + traceParent._pushContext(); + var result = tryCatch(yieldHandlers[i])(value); + traceParent._popContext(); + if (result === errorObj) { + traceParent._pushContext(); + var ret = Promise.reject(errorObj.e); + traceParent._popContext(); + return ret; + } + var maybePromise = tryConvertToPromise(result, traceParent); + if (maybePromise instanceof Promise) return maybePromise; + } + return null; +} + +function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) { + if (debug.cancellation()) { + var internal = new Promise(INTERNAL); + var _finallyPromise = this._finallyPromise = new Promise(INTERNAL); + this._promise = internal.lastly(function() { + return _finallyPromise; + }); + internal._captureStackTrace(); + internal._setOnCancel(this); + } else { + var promise = this._promise = new Promise(INTERNAL); + promise._captureStackTrace(); + } + this._stack = stack; + this._generatorFunction = generatorFunction; + this._receiver = receiver; + this._generator = undefined; + this._yieldHandlers = typeof yieldHandler === "function" + ? [yieldHandler].concat(yieldHandlers) + : yieldHandlers; + this._yieldedPromise = null; + this._cancellationPhase = false; +} +util.inherits(PromiseSpawn, Proxyable); + +PromiseSpawn.prototype._isResolved = function() { + return this._promise === null; +}; + +PromiseSpawn.prototype._cleanup = function() { + this._promise = this._generator = null; + if (debug.cancellation() && this._finallyPromise !== null) { + this._finallyPromise._fulfill(); + this._finallyPromise = null; + } +}; + +PromiseSpawn.prototype._promiseCancelled = function() { + if (this._isResolved()) return; + var implementsReturn = typeof this._generator["return"] !== "undefined"; + + var result; + if (!implementsReturn) { + var reason = new Promise.CancellationError( + "generator .return() sentinel"); + Promise.coroutine.returnSentinel = reason; + this._promise._attachExtraTrace(reason); + this._promise._pushContext(); + result = tryCatch(this._generator["throw"]).call(this._generator, + reason); + this._promise._popContext(); + } else { + this._promise._pushContext(); + result = tryCatch(this._generator["return"]).call(this._generator, + undefined); + this._promise._popContext(); + } + this._cancellationPhase = true; + this._yieldedPromise = null; + this._continue(result); +}; + +PromiseSpawn.prototype._promiseFulfilled = function(value) { + this._yieldedPromise = null; + this._promise._pushContext(); + var result = tryCatch(this._generator.next).call(this._generator, value); + this._promise._popContext(); + this._continue(result); +}; + +PromiseSpawn.prototype._promiseRejected = function(reason) { + this._yieldedPromise = null; + this._promise._attachExtraTrace(reason); + this._promise._pushContext(); + var result = tryCatch(this._generator["throw"]) + .call(this._generator, reason); + this._promise._popContext(); + this._continue(result); +}; + +PromiseSpawn.prototype._resultCancelled = function() { + if (this._yieldedPromise instanceof Promise) { + var promise = this._yieldedPromise; + this._yieldedPromise = null; + promise.cancel(); + } +}; + +PromiseSpawn.prototype.promise = function () { + return this._promise; +}; + +PromiseSpawn.prototype._run = function () { + this._generator = this._generatorFunction.call(this._receiver); + this._receiver = + this._generatorFunction = undefined; + this._promiseFulfilled(undefined); +}; + +PromiseSpawn.prototype._continue = function (result) { + var promise = this._promise; + if (result === errorObj) { + this._cleanup(); + if (this._cancellationPhase) { + return promise.cancel(); + } else { + return promise._rejectCallback(result.e, false); + } + } + + var value = result.value; + if (result.done === true) { + this._cleanup(); + if (this._cancellationPhase) { + return promise.cancel(); + } else { + return promise._resolveCallback(value); + } + } else { + var maybePromise = tryConvertToPromise(value, this._promise); + if (!(maybePromise instanceof Promise)) { + maybePromise = + promiseFromYieldHandler(maybePromise, + this._yieldHandlers, + this._promise); + if (maybePromise === null) { + this._promiseRejected( + new TypeError( + "A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", String(value)) + + "From coroutine:\u000a" + + this._stack.split("\n").slice(1, -7).join("\n") + ) + ); + return; + } + } + maybePromise = maybePromise._target(); + var bitField = maybePromise._bitField; + ; + if (((bitField & 50397184) === 0)) { + this._yieldedPromise = maybePromise; + maybePromise._proxy(this, null); + } else if (((bitField & 33554432) !== 0)) { + Promise._async.invoke( + this._promiseFulfilled, this, maybePromise._value() + ); + } else if (((bitField & 16777216) !== 0)) { + Promise._async.invoke( + this._promiseRejected, this, maybePromise._reason() + ); + } else { + this._promiseCancelled(); + } + } +}; + +Promise.coroutine = function (generatorFunction, options) { + if (typeof generatorFunction !== "function") { + throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + var yieldHandler = Object(options).yieldHandler; + var PromiseSpawn$ = PromiseSpawn; + var stack = new Error().stack; + return function () { + var generator = generatorFunction.apply(this, arguments); + var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler, + stack); + var ret = spawn.promise(); + spawn._generator = generator; + spawn._promiseFulfilled(undefined); + return ret; + }; +}; + +Promise.coroutine.addYieldHandler = function(fn) { + if (typeof fn !== "function") { + throw new TypeError("expecting a function but got " + util.classString(fn)); + } + yieldHandlers.push(fn); +}; + +Promise.spawn = function (generatorFunction) { + debug.deprecated("Promise.spawn()", "Promise.coroutine()"); + if (typeof generatorFunction !== "function") { + return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + var spawn = new PromiseSpawn(generatorFunction, this); + var ret = spawn.promise(); + spawn._run(Promise.spawn); + return ret; +}; +}; + +},{"./errors":12,"./util":36}],17:[function(_dereq_,module,exports){ +"use strict"; +module.exports = +function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, + getDomain) { +var util = _dereq_("./util"); +var canEvaluate = util.canEvaluate; +var tryCatch = util.tryCatch; +var errorObj = util.errorObj; +var reject; + +if (!true) { +if (canEvaluate) { + var thenCallback = function(i) { + return new Function("value", "holder", " \n\ + 'use strict'; \n\ + holder.pIndex = value; \n\ + holder.checkFulfillment(this); \n\ + ".replace(/Index/g, i)); + }; + + var promiseSetter = function(i) { + return new Function("promise", "holder", " \n\ + 'use strict'; \n\ + holder.pIndex = promise; \n\ + ".replace(/Index/g, i)); + }; + + var generateHolderClass = function(total) { + var props = new Array(total); + for (var i = 0; i < props.length; ++i) { + props[i] = "this.p" + (i+1); + } + var assignment = props.join(" = ") + " = null;"; + var cancellationCode= "var promise;\n" + props.map(function(prop) { + return " \n\ + promise = " + prop + "; \n\ + if (promise instanceof Promise) { \n\ + promise.cancel(); \n\ + } \n\ + "; + }).join("\n"); + var passedArguments = props.join(", "); + var name = "Holder$" + total; + + + var code = "return function(tryCatch, errorObj, Promise, async) { \n\ + 'use strict'; \n\ + function [TheName](fn) { \n\ + [TheProperties] \n\ + this.fn = fn; \n\ + this.asyncNeeded = true; \n\ + this.now = 0; \n\ + } \n\ + \n\ + [TheName].prototype._callFunction = function(promise) { \n\ + promise._pushContext(); \n\ + var ret = tryCatch(this.fn)([ThePassedArguments]); \n\ + promise._popContext(); \n\ + if (ret === errorObj) { \n\ + promise._rejectCallback(ret.e, false); \n\ + } else { \n\ + promise._resolveCallback(ret); \n\ + } \n\ + }; \n\ + \n\ + [TheName].prototype.checkFulfillment = function(promise) { \n\ + var now = ++this.now; \n\ + if (now === [TheTotal]) { \n\ + if (this.asyncNeeded) { \n\ + async.invoke(this._callFunction, this, promise); \n\ + } else { \n\ + this._callFunction(promise); \n\ + } \n\ + \n\ + } \n\ + }; \n\ + \n\ + [TheName].prototype._resultCancelled = function() { \n\ + [CancellationCode] \n\ + }; \n\ + \n\ + return [TheName]; \n\ + }(tryCatch, errorObj, Promise, async); \n\ + "; + + code = code.replace(/\[TheName\]/g, name) + .replace(/\[TheTotal\]/g, total) + .replace(/\[ThePassedArguments\]/g, passedArguments) + .replace(/\[TheProperties\]/g, assignment) + .replace(/\[CancellationCode\]/g, cancellationCode); + + return new Function("tryCatch", "errorObj", "Promise", "async", code) + (tryCatch, errorObj, Promise, async); + }; + + var holderClasses = []; + var thenCallbacks = []; + var promiseSetters = []; + + for (var i = 0; i < 8; ++i) { + holderClasses.push(generateHolderClass(i + 1)); + thenCallbacks.push(thenCallback(i + 1)); + promiseSetters.push(promiseSetter(i + 1)); + } + + reject = function (reason) { + this._reject(reason); + }; +}} + +Promise.join = function () { + var last = arguments.length - 1; + var fn; + if (last > 0 && typeof arguments[last] === "function") { + fn = arguments[last]; + if (!true) { + if (last <= 8 && canEvaluate) { + var ret = new Promise(INTERNAL); + ret._captureStackTrace(); + var HolderClass = holderClasses[last - 1]; + var holder = new HolderClass(fn); + var callbacks = thenCallbacks; + + for (var i = 0; i < last; ++i) { + var maybePromise = tryConvertToPromise(arguments[i], ret); + if (maybePromise instanceof Promise) { + maybePromise = maybePromise._target(); + var bitField = maybePromise._bitField; + ; + if (((bitField & 50397184) === 0)) { + maybePromise._then(callbacks[i], reject, + undefined, ret, holder); + promiseSetters[i](maybePromise, holder); + holder.asyncNeeded = false; + } else if (((bitField & 33554432) !== 0)) { + callbacks[i].call(ret, + maybePromise._value(), holder); + } else if (((bitField & 16777216) !== 0)) { + ret._reject(maybePromise._reason()); + } else { + ret._cancel(); + } + } else { + callbacks[i].call(ret, maybePromise, holder); + } + } + + if (!ret._isFateSealed()) { + if (holder.asyncNeeded) { + var domain = getDomain(); + if (domain !== null) { + holder.fn = util.domainBind(domain, holder.fn); + } + } + ret._setAsyncGuaranteed(); + ret._setOnCancel(holder); + } + return ret; + } + } + } + var args = [].slice.call(arguments);; + if (fn) args.pop(); + var ret = new PromiseArray(args).promise(); + return fn !== undefined ? ret.spread(fn) : ret; +}; + +}; + +},{"./util":36}],18:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, + PromiseArray, + apiRejection, + tryConvertToPromise, + INTERNAL, + debug) { +var getDomain = Promise._getDomain; +var util = _dereq_("./util"); +var tryCatch = util.tryCatch; +var errorObj = util.errorObj; +var async = Promise._async; + +function MappingPromiseArray(promises, fn, limit, _filter) { + this.constructor$(promises); + this._promise._captureStackTrace(); + var domain = getDomain(); + this._callback = domain === null ? fn : util.domainBind(domain, fn); + this._preservedValues = _filter === INTERNAL + ? new Array(this.length()) + : null; + this._limit = limit; + this._inFlight = 0; + this._queue = []; + async.invoke(this._asyncInit, this, undefined); +} +util.inherits(MappingPromiseArray, PromiseArray); + +MappingPromiseArray.prototype._asyncInit = function() { + this._init$(undefined, -2); +}; + +MappingPromiseArray.prototype._init = function () {}; + +MappingPromiseArray.prototype._promiseFulfilled = function (value, index) { + var values = this._values; + var length = this.length(); + var preservedValues = this._preservedValues; + var limit = this._limit; + + if (index < 0) { + index = (index * -1) - 1; + values[index] = value; + if (limit >= 1) { + this._inFlight--; + this._drainQueue(); + if (this._isResolved()) return true; + } + } else { + if (limit >= 1 && this._inFlight >= limit) { + values[index] = value; + this._queue.push(index); + return false; + } + if (preservedValues !== null) preservedValues[index] = value; + + var promise = this._promise; + var callback = this._callback; + var receiver = promise._boundValue(); + promise._pushContext(); + var ret = tryCatch(callback).call(receiver, value, index, length); + var promiseCreated = promise._popContext(); + debug.checkForgottenReturns( + ret, + promiseCreated, + preservedValues !== null ? "Promise.filter" : "Promise.map", + promise + ); + if (ret === errorObj) { + this._reject(ret.e); + return true; + } + + var maybePromise = tryConvertToPromise(ret, this._promise); + if (maybePromise instanceof Promise) { + maybePromise = maybePromise._target(); + var bitField = maybePromise._bitField; + ; + if (((bitField & 50397184) === 0)) { + if (limit >= 1) this._inFlight++; + values[index] = maybePromise; + maybePromise._proxy(this, (index + 1) * -1); + return false; + } else if (((bitField & 33554432) !== 0)) { + ret = maybePromise._value(); + } else if (((bitField & 16777216) !== 0)) { + this._reject(maybePromise._reason()); + return true; + } else { + this._cancel(); + return true; + } + } + values[index] = ret; + } + var totalResolved = ++this._totalResolved; + if (totalResolved >= length) { + if (preservedValues !== null) { + this._filter(values, preservedValues); + } else { + this._resolve(values); + } + return true; + } + return false; +}; + +MappingPromiseArray.prototype._drainQueue = function () { + var queue = this._queue; + var limit = this._limit; + var values = this._values; + while (queue.length > 0 && this._inFlight < limit) { + if (this._isResolved()) return; + var index = queue.pop(); + this._promiseFulfilled(values[index], index); + } +}; + +MappingPromiseArray.prototype._filter = function (booleans, values) { + var len = values.length; + var ret = new Array(len); + var j = 0; + for (var i = 0; i < len; ++i) { + if (booleans[i]) ret[j++] = values[i]; + } + ret.length = j; + this._resolve(ret); +}; + +MappingPromiseArray.prototype.preservedValues = function () { + return this._preservedValues; +}; + +function map(promises, fn, options, _filter) { + if (typeof fn !== "function") { + return apiRejection("expecting a function but got " + util.classString(fn)); + } + + var limit = 0; + if (options !== undefined) { + if (typeof options === "object" && options !== null) { + if (typeof options.concurrency !== "number") { + return Promise.reject( + new TypeError("'concurrency' must be a number but it is " + + util.classString(options.concurrency))); + } + limit = options.concurrency; + } else { + return Promise.reject(new TypeError( + "options argument must be an object but it is " + + util.classString(options))); + } + } + limit = typeof limit === "number" && + isFinite(limit) && limit >= 1 ? limit : 0; + return new MappingPromiseArray(promises, fn, limit, _filter).promise(); +} + +Promise.prototype.map = function (fn, options) { + return map(this, fn, options, null); +}; + +Promise.map = function (promises, fn, options, _filter) { + return map(promises, fn, options, _filter); +}; + + +}; + +},{"./util":36}],19:[function(_dereq_,module,exports){ +"use strict"; +module.exports = +function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) { +var util = _dereq_("./util"); +var tryCatch = util.tryCatch; + +Promise.method = function (fn) { + if (typeof fn !== "function") { + throw new Promise.TypeError("expecting a function but got " + util.classString(fn)); + } + return function () { + var ret = new Promise(INTERNAL); + ret._captureStackTrace(); + ret._pushContext(); + var value = tryCatch(fn).apply(this, arguments); + var promiseCreated = ret._popContext(); + debug.checkForgottenReturns( + value, promiseCreated, "Promise.method", ret); + ret._resolveFromSyncValue(value); + return ret; + }; +}; + +Promise.attempt = Promise["try"] = function (fn) { + if (typeof fn !== "function") { + return apiRejection("expecting a function but got " + util.classString(fn)); + } + var ret = new Promise(INTERNAL); + ret._captureStackTrace(); + ret._pushContext(); + var value; + if (arguments.length > 1) { + debug.deprecated("calling Promise.try with more than 1 argument"); + var arg = arguments[1]; + var ctx = arguments[2]; + value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg) + : tryCatch(fn).call(ctx, arg); + } else { + value = tryCatch(fn)(); + } + var promiseCreated = ret._popContext(); + debug.checkForgottenReturns( + value, promiseCreated, "Promise.try", ret); + ret._resolveFromSyncValue(value); + return ret; +}; + +Promise.prototype._resolveFromSyncValue = function (value) { + if (value === util.errorObj) { + this._rejectCallback(value.e, false); + } else { + this._resolveCallback(value, true); + } +}; +}; + +},{"./util":36}],20:[function(_dereq_,module,exports){ +"use strict"; +var util = _dereq_("./util"); +var maybeWrapAsError = util.maybeWrapAsError; +var errors = _dereq_("./errors"); +var OperationalError = errors.OperationalError; +var es5 = _dereq_("./es5"); + +function isUntypedError(obj) { + return obj instanceof Error && + es5.getPrototypeOf(obj) === Error.prototype; +} + +var rErrorKey = /^(?:name|message|stack|cause)$/; +function wrapAsOperationalError(obj) { + var ret; + if (isUntypedError(obj)) { + ret = new OperationalError(obj); + ret.name = obj.name; + ret.message = obj.message; + ret.stack = obj.stack; + var keys = es5.keys(obj); + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + if (!rErrorKey.test(key)) { + ret[key] = obj[key]; + } + } + return ret; + } + util.markAsOriginatingFromRejection(obj); + return obj; +} + +function nodebackForPromise(promise, multiArgs) { + return function(err, value) { + if (promise === null) return; + if (err) { + var wrapped = wrapAsOperationalError(maybeWrapAsError(err)); + promise._attachExtraTrace(wrapped); + promise._reject(wrapped); + } else if (!multiArgs) { + promise._fulfill(value); + } else { + var args = [].slice.call(arguments, 1);; + promise._fulfill(args); + } + promise = null; + }; +} + +module.exports = nodebackForPromise; + +},{"./errors":12,"./es5":13,"./util":36}],21:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise) { +var util = _dereq_("./util"); +var async = Promise._async; +var tryCatch = util.tryCatch; +var errorObj = util.errorObj; + +function spreadAdapter(val, nodeback) { + var promise = this; + if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback); + var ret = + tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val)); + if (ret === errorObj) { + async.throwLater(ret.e); + } +} + +function successAdapter(val, nodeback) { + var promise = this; + var receiver = promise._boundValue(); + var ret = val === undefined + ? tryCatch(nodeback).call(receiver, null) + : tryCatch(nodeback).call(receiver, null, val); + if (ret === errorObj) { + async.throwLater(ret.e); + } +} +function errorAdapter(reason, nodeback) { + var promise = this; + if (!reason) { + var newReason = new Error(reason + ""); + newReason.cause = reason; + reason = newReason; + } + var ret = tryCatch(nodeback).call(promise._boundValue(), reason); + if (ret === errorObj) { + async.throwLater(ret.e); + } +} + +Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback, + options) { + if (typeof nodeback == "function") { + var adapter = successAdapter; + if (options !== undefined && Object(options).spread) { + adapter = spreadAdapter; + } + this._then( + adapter, + errorAdapter, + undefined, + this, + nodeback + ); + } + return this; +}; +}; + +},{"./util":36}],22:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function() { +var makeSelfResolutionError = function () { + return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/MqrFmX\u000a"); +}; +var reflectHandler = function() { + return new Promise.PromiseInspection(this._target()); +}; +var apiRejection = function(msg) { + return Promise.reject(new TypeError(msg)); +}; +function Proxyable() {} +var UNDEFINED_BINDING = {}; +var util = _dereq_("./util"); + +var getDomain; +if (util.isNode) { + getDomain = function() { + var ret = process.domain; + if (ret === undefined) ret = null; + return ret; + }; +} else { + getDomain = function() { + return null; + }; +} +util.notEnumerableProp(Promise, "_getDomain", getDomain); + +var es5 = _dereq_("./es5"); +var Async = _dereq_("./async"); +var async = new Async(); +es5.defineProperty(Promise, "_async", {value: async}); +var errors = _dereq_("./errors"); +var TypeError = Promise.TypeError = errors.TypeError; +Promise.RangeError = errors.RangeError; +var CancellationError = Promise.CancellationError = errors.CancellationError; +Promise.TimeoutError = errors.TimeoutError; +Promise.OperationalError = errors.OperationalError; +Promise.RejectionError = errors.OperationalError; +Promise.AggregateError = errors.AggregateError; +var INTERNAL = function(){}; +var APPLY = {}; +var NEXT_FILTER = {}; +var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL); +var PromiseArray = + _dereq_("./promise_array")(Promise, INTERNAL, + tryConvertToPromise, apiRejection, Proxyable); +var Context = _dereq_("./context")(Promise); + /*jshint unused:false*/ +var createContext = Context.create; +var debug = _dereq_("./debuggability")(Promise, Context); +var CapturedTrace = debug.CapturedTrace; +var PassThroughHandlerContext = + _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER); +var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER); +var nodebackForPromise = _dereq_("./nodeback"); +var errorObj = util.errorObj; +var tryCatch = util.tryCatch; +function check(self, executor) { + if (self == null || self.constructor !== Promise) { + throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + if (typeof executor !== "function") { + throw new TypeError("expecting a function but got " + util.classString(executor)); + } + +} + +function Promise(executor) { + if (executor !== INTERNAL) { + check(this, executor); + } + this._bitField = 0; + this._fulfillmentHandler0 = undefined; + this._rejectionHandler0 = undefined; + this._promise0 = undefined; + this._receiver0 = undefined; + this._resolveFromExecutor(executor); + this._promiseCreated(); + this._fireEvent("promiseCreated", this); +} + +Promise.prototype.toString = function () { + return "[object Promise]"; +}; + +Promise.prototype.caught = Promise.prototype["catch"] = function (fn) { + var len = arguments.length; + if (len > 1) { + var catchInstances = new Array(len - 1), + j = 0, i; + for (i = 0; i < len - 1; ++i) { + var item = arguments[i]; + if (util.isObject(item)) { + catchInstances[j++] = item; + } else { + return apiRejection("Catch statement predicate: " + + "expecting an object but got " + util.classString(item)); + } + } + catchInstances.length = j; + fn = arguments[i]; + return this.then(undefined, catchFilter(catchInstances, fn, this)); + } + return this.then(undefined, fn); +}; + +Promise.prototype.reflect = function () { + return this._then(reflectHandler, + reflectHandler, undefined, this, undefined); +}; + +Promise.prototype.then = function (didFulfill, didReject) { + if (debug.warnings() && arguments.length > 0 && + typeof didFulfill !== "function" && + typeof didReject !== "function") { + var msg = ".then() only accepts functions but was passed: " + + util.classString(didFulfill); + if (arguments.length > 1) { + msg += ", " + util.classString(didReject); + } + this._warn(msg); + } + return this._then(didFulfill, didReject, undefined, undefined, undefined); +}; + +Promise.prototype.done = function (didFulfill, didReject) { + var promise = + this._then(didFulfill, didReject, undefined, undefined, undefined); + promise._setIsFinal(); +}; + +Promise.prototype.spread = function (fn) { + if (typeof fn !== "function") { + return apiRejection("expecting a function but got " + util.classString(fn)); + } + return this.all()._then(fn, undefined, undefined, APPLY, undefined); +}; + +Promise.prototype.toJSON = function () { + var ret = { + isFulfilled: false, + isRejected: false, + fulfillmentValue: undefined, + rejectionReason: undefined + }; + if (this.isFulfilled()) { + ret.fulfillmentValue = this.value(); + ret.isFulfilled = true; + } else if (this.isRejected()) { + ret.rejectionReason = this.reason(); + ret.isRejected = true; + } + return ret; +}; + +Promise.prototype.all = function () { + if (arguments.length > 0) { + this._warn(".all() was passed arguments but it does not take any"); + } + return new PromiseArray(this).promise(); +}; + +Promise.prototype.error = function (fn) { + return this.caught(util.originatesFromRejection, fn); +}; + +Promise.getNewLibraryCopy = module.exports; + +Promise.is = function (val) { + return val instanceof Promise; +}; + +Promise.fromNode = Promise.fromCallback = function(fn) { + var ret = new Promise(INTERNAL); + ret._captureStackTrace(); + var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs + : false; + var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs)); + if (result === errorObj) { + ret._rejectCallback(result.e, true); + } + if (!ret._isFateSealed()) ret._setAsyncGuaranteed(); + return ret; +}; + +Promise.all = function (promises) { + return new PromiseArray(promises).promise(); +}; + +Promise.cast = function (obj) { + var ret = tryConvertToPromise(obj); + if (!(ret instanceof Promise)) { + ret = new Promise(INTERNAL); + ret._captureStackTrace(); + ret._setFulfilled(); + ret._rejectionHandler0 = obj; + } + return ret; +}; + +Promise.resolve = Promise.fulfilled = Promise.cast; + +Promise.reject = Promise.rejected = function (reason) { + var ret = new Promise(INTERNAL); + ret._captureStackTrace(); + ret._rejectCallback(reason, true); + return ret; +}; + +Promise.setScheduler = function(fn) { + if (typeof fn !== "function") { + throw new TypeError("expecting a function but got " + util.classString(fn)); + } + return async.setScheduler(fn); +}; + +Promise.prototype._then = function ( + didFulfill, + didReject, + _, receiver, + internalData +) { + var haveInternalData = internalData !== undefined; + var promise = haveInternalData ? internalData : new Promise(INTERNAL); + var target = this._target(); + var bitField = target._bitField; + + if (!haveInternalData) { + promise._propagateFrom(this, 3); + promise._captureStackTrace(); + if (receiver === undefined && + ((this._bitField & 2097152) !== 0)) { + if (!((bitField & 50397184) === 0)) { + receiver = this._boundValue(); + } else { + receiver = target === this ? undefined : this._boundTo; + } + } + this._fireEvent("promiseChained", this, promise); + } + + var domain = getDomain(); + if (!((bitField & 50397184) === 0)) { + var handler, value, settler = target._settlePromiseCtx; + if (((bitField & 33554432) !== 0)) { + value = target._rejectionHandler0; + handler = didFulfill; + } else if (((bitField & 16777216) !== 0)) { + value = target._fulfillmentHandler0; + handler = didReject; + target._unsetRejectionIsUnhandled(); + } else { + settler = target._settlePromiseLateCancellationObserver; + value = new CancellationError("late cancellation observer"); + target._attachExtraTrace(value); + handler = didReject; + } + + async.invoke(settler, target, { + handler: domain === null ? handler + : (typeof handler === "function" && + util.domainBind(domain, handler)), + promise: promise, + receiver: receiver, + value: value + }); + } else { + target._addCallbacks(didFulfill, didReject, promise, receiver, domain); + } + + return promise; +}; + +Promise.prototype._length = function () { + return this._bitField & 65535; +}; + +Promise.prototype._isFateSealed = function () { + return (this._bitField & 117506048) !== 0; +}; + +Promise.prototype._isFollowing = function () { + return (this._bitField & 67108864) === 67108864; +}; + +Promise.prototype._setLength = function (len) { + this._bitField = (this._bitField & -65536) | + (len & 65535); +}; + +Promise.prototype._setFulfilled = function () { + this._bitField = this._bitField | 33554432; + this._fireEvent("promiseFulfilled", this); +}; + +Promise.prototype._setRejected = function () { + this._bitField = this._bitField | 16777216; + this._fireEvent("promiseRejected", this); +}; + +Promise.prototype._setFollowing = function () { + this._bitField = this._bitField | 67108864; + this._fireEvent("promiseResolved", this); +}; + +Promise.prototype._setIsFinal = function () { + this._bitField = this._bitField | 4194304; +}; + +Promise.prototype._isFinal = function () { + return (this._bitField & 4194304) > 0; +}; + +Promise.prototype._unsetCancelled = function() { + this._bitField = this._bitField & (~65536); +}; + +Promise.prototype._setCancelled = function() { + this._bitField = this._bitField | 65536; + this._fireEvent("promiseCancelled", this); +}; + +Promise.prototype._setWillBeCancelled = function() { + this._bitField = this._bitField | 8388608; +}; + +Promise.prototype._setAsyncGuaranteed = function() { + if (async.hasCustomScheduler()) return; + this._bitField = this._bitField | 134217728; +}; + +Promise.prototype._receiverAt = function (index) { + var ret = index === 0 ? this._receiver0 : this[ + index * 4 - 4 + 3]; + if (ret === UNDEFINED_BINDING) { + return undefined; + } else if (ret === undefined && this._isBound()) { + return this._boundValue(); + } + return ret; +}; + +Promise.prototype._promiseAt = function (index) { + return this[ + index * 4 - 4 + 2]; +}; + +Promise.prototype._fulfillmentHandlerAt = function (index) { + return this[ + index * 4 - 4 + 0]; +}; + +Promise.prototype._rejectionHandlerAt = function (index) { + return this[ + index * 4 - 4 + 1]; +}; + +Promise.prototype._boundValue = function() {}; + +Promise.prototype._migrateCallback0 = function (follower) { + var bitField = follower._bitField; + var fulfill = follower._fulfillmentHandler0; + var reject = follower._rejectionHandler0; + var promise = follower._promise0; + var receiver = follower._receiverAt(0); + if (receiver === undefined) receiver = UNDEFINED_BINDING; + this._addCallbacks(fulfill, reject, promise, receiver, null); +}; + +Promise.prototype._migrateCallbackAt = function (follower, index) { + var fulfill = follower._fulfillmentHandlerAt(index); + var reject = follower._rejectionHandlerAt(index); + var promise = follower._promiseAt(index); + var receiver = follower._receiverAt(index); + if (receiver === undefined) receiver = UNDEFINED_BINDING; + this._addCallbacks(fulfill, reject, promise, receiver, null); +}; + +Promise.prototype._addCallbacks = function ( + fulfill, + reject, + promise, + receiver, + domain +) { + var index = this._length(); + + if (index >= 65535 - 4) { + index = 0; + this._setLength(0); + } + + if (index === 0) { + this._promise0 = promise; + this._receiver0 = receiver; + if (typeof fulfill === "function") { + this._fulfillmentHandler0 = + domain === null ? fulfill : util.domainBind(domain, fulfill); + } + if (typeof reject === "function") { + this._rejectionHandler0 = + domain === null ? reject : util.domainBind(domain, reject); + } + } else { + var base = index * 4 - 4; + this[base + 2] = promise; + this[base + 3] = receiver; + if (typeof fulfill === "function") { + this[base + 0] = + domain === null ? fulfill : util.domainBind(domain, fulfill); + } + if (typeof reject === "function") { + this[base + 1] = + domain === null ? reject : util.domainBind(domain, reject); + } + } + this._setLength(index + 1); + return index; +}; + +Promise.prototype._proxy = function (proxyable, arg) { + this._addCallbacks(undefined, undefined, arg, proxyable, null); +}; + +Promise.prototype._resolveCallback = function(value, shouldBind) { + if (((this._bitField & 117506048) !== 0)) return; + if (value === this) + return this._rejectCallback(makeSelfResolutionError(), false); + var maybePromise = tryConvertToPromise(value, this); + if (!(maybePromise instanceof Promise)) return this._fulfill(value); + + if (shouldBind) this._propagateFrom(maybePromise, 2); + + var promise = maybePromise._target(); + + if (promise === this) { + this._reject(makeSelfResolutionError()); + return; + } + + var bitField = promise._bitField; + if (((bitField & 50397184) === 0)) { + var len = this._length(); + if (len > 0) promise._migrateCallback0(this); + for (var i = 1; i < len; ++i) { + promise._migrateCallbackAt(this, i); + } + this._setFollowing(); + this._setLength(0); + this._setFollowee(promise); + } else if (((bitField & 33554432) !== 0)) { + this._fulfill(promise._value()); + } else if (((bitField & 16777216) !== 0)) { + this._reject(promise._reason()); + } else { + var reason = new CancellationError("late cancellation observer"); + promise._attachExtraTrace(reason); + this._reject(reason); + } +}; + +Promise.prototype._rejectCallback = +function(reason, synchronous, ignoreNonErrorWarnings) { + var trace = util.ensureErrorObject(reason); + var hasStack = trace === reason; + if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) { + var message = "a promise was rejected with a non-error: " + + util.classString(reason); + this._warn(message, true); + } + this._attachExtraTrace(trace, synchronous ? hasStack : false); + this._reject(reason); +}; + +Promise.prototype._resolveFromExecutor = function (executor) { + if (executor === INTERNAL) return; + var promise = this; + this._captureStackTrace(); + this._pushContext(); + var synchronous = true; + var r = this._execute(executor, function(value) { + promise._resolveCallback(value); + }, function (reason) { + promise._rejectCallback(reason, synchronous); + }); + synchronous = false; + this._popContext(); + + if (r !== undefined) { + promise._rejectCallback(r, true); + } +}; + +Promise.prototype._settlePromiseFromHandler = function ( + handler, receiver, value, promise +) { + var bitField = promise._bitField; + if (((bitField & 65536) !== 0)) return; + promise._pushContext(); + var x; + if (receiver === APPLY) { + if (!value || typeof value.length !== "number") { + x = errorObj; + x.e = new TypeError("cannot .spread() a non-array: " + + util.classString(value)); + } else { + x = tryCatch(handler).apply(this._boundValue(), value); + } + } else { + x = tryCatch(handler).call(receiver, value); + } + var promiseCreated = promise._popContext(); + bitField = promise._bitField; + if (((bitField & 65536) !== 0)) return; + + if (x === NEXT_FILTER) { + promise._reject(value); + } else if (x === errorObj) { + promise._rejectCallback(x.e, false); + } else { + debug.checkForgottenReturns(x, promiseCreated, "", promise, this); + promise._resolveCallback(x); + } +}; + +Promise.prototype._target = function() { + var ret = this; + while (ret._isFollowing()) ret = ret._followee(); + return ret; +}; + +Promise.prototype._followee = function() { + return this._rejectionHandler0; +}; + +Promise.prototype._setFollowee = function(promise) { + this._rejectionHandler0 = promise; +}; + +Promise.prototype._settlePromise = function(promise, handler, receiver, value) { + var isPromise = promise instanceof Promise; + var bitField = this._bitField; + var asyncGuaranteed = ((bitField & 134217728) !== 0); + if (((bitField & 65536) !== 0)) { + if (isPromise) promise._invokeInternalOnCancel(); + + if (receiver instanceof PassThroughHandlerContext && + receiver.isFinallyHandler()) { + receiver.cancelPromise = promise; + if (tryCatch(handler).call(receiver, value) === errorObj) { + promise._reject(errorObj.e); + } + } else if (handler === reflectHandler) { + promise._fulfill(reflectHandler.call(receiver)); + } else if (receiver instanceof Proxyable) { + receiver._promiseCancelled(promise); + } else if (isPromise || promise instanceof PromiseArray) { + promise._cancel(); + } else { + receiver.cancel(); + } + } else if (typeof handler === "function") { + if (!isPromise) { + handler.call(receiver, value, promise); + } else { + if (asyncGuaranteed) promise._setAsyncGuaranteed(); + this._settlePromiseFromHandler(handler, receiver, value, promise); + } + } else if (receiver instanceof Proxyable) { + if (!receiver._isResolved()) { + if (((bitField & 33554432) !== 0)) { + receiver._promiseFulfilled(value, promise); + } else { + receiver._promiseRejected(value, promise); + } + } + } else if (isPromise) { + if (asyncGuaranteed) promise._setAsyncGuaranteed(); + if (((bitField & 33554432) !== 0)) { + promise._fulfill(value); + } else { + promise._reject(value); + } + } +}; + +Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) { + var handler = ctx.handler; + var promise = ctx.promise; + var receiver = ctx.receiver; + var value = ctx.value; + if (typeof handler === "function") { + if (!(promise instanceof Promise)) { + handler.call(receiver, value, promise); + } else { + this._settlePromiseFromHandler(handler, receiver, value, promise); + } + } else if (promise instanceof Promise) { + promise._reject(value); + } +}; + +Promise.prototype._settlePromiseCtx = function(ctx) { + this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value); +}; + +Promise.prototype._settlePromise0 = function(handler, value, bitField) { + var promise = this._promise0; + var receiver = this._receiverAt(0); + this._promise0 = undefined; + this._receiver0 = undefined; + this._settlePromise(promise, handler, receiver, value); +}; + +Promise.prototype._clearCallbackDataAtIndex = function(index) { + var base = index * 4 - 4; + this[base + 2] = + this[base + 3] = + this[base + 0] = + this[base + 1] = undefined; +}; + +Promise.prototype._fulfill = function (value) { + var bitField = this._bitField; + if (((bitField & 117506048) >>> 16)) return; + if (value === this) { + var err = makeSelfResolutionError(); + this._attachExtraTrace(err); + return this._reject(err); + } + this._setFulfilled(); + this._rejectionHandler0 = value; + + if ((bitField & 65535) > 0) { + if (((bitField & 134217728) !== 0)) { + this._settlePromises(); + } else { + async.settlePromises(this); + } + this._dereferenceTrace(); + } +}; + +Promise.prototype._reject = function (reason) { + var bitField = this._bitField; + if (((bitField & 117506048) >>> 16)) return; + this._setRejected(); + this._fulfillmentHandler0 = reason; + + if (this._isFinal()) { + return async.fatalError(reason, util.isNode); + } + + if ((bitField & 65535) > 0) { + async.settlePromises(this); + } else { + this._ensurePossibleRejectionHandled(); + } +}; + +Promise.prototype._fulfillPromises = function (len, value) { + for (var i = 1; i < len; i++) { + var handler = this._fulfillmentHandlerAt(i); + var promise = this._promiseAt(i); + var receiver = this._receiverAt(i); + this._clearCallbackDataAtIndex(i); + this._settlePromise(promise, handler, receiver, value); + } +}; + +Promise.prototype._rejectPromises = function (len, reason) { + for (var i = 1; i < len; i++) { + var handler = this._rejectionHandlerAt(i); + var promise = this._promiseAt(i); + var receiver = this._receiverAt(i); + this._clearCallbackDataAtIndex(i); + this._settlePromise(promise, handler, receiver, reason); + } +}; + +Promise.prototype._settlePromises = function () { + var bitField = this._bitField; + var len = (bitField & 65535); + + if (len > 0) { + if (((bitField & 16842752) !== 0)) { + var reason = this._fulfillmentHandler0; + this._settlePromise0(this._rejectionHandler0, reason, bitField); + this._rejectPromises(len, reason); + } else { + var value = this._rejectionHandler0; + this._settlePromise0(this._fulfillmentHandler0, value, bitField); + this._fulfillPromises(len, value); + } + this._setLength(0); + } + this._clearCancellationData(); +}; + +Promise.prototype._settledValue = function() { + var bitField = this._bitField; + if (((bitField & 33554432) !== 0)) { + return this._rejectionHandler0; + } else if (((bitField & 16777216) !== 0)) { + return this._fulfillmentHandler0; + } +}; + +function deferResolve(v) {this.promise._resolveCallback(v);} +function deferReject(v) {this.promise._rejectCallback(v, false);} + +Promise.defer = Promise.pending = function() { + debug.deprecated("Promise.defer", "new Promise"); + var promise = new Promise(INTERNAL); + return { + promise: promise, + resolve: deferResolve, + reject: deferReject + }; +}; + +util.notEnumerableProp(Promise, + "_makeSelfResolutionError", + makeSelfResolutionError); + +_dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection, + debug); +_dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug); +_dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug); +_dereq_("./direct_resolve")(Promise); +_dereq_("./synchronous_inspection")(Promise); +_dereq_("./join")( + Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain); +Promise.Promise = Promise; +Promise.version = "3.5.2"; +_dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); +_dereq_('./call_get.js')(Promise); +_dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); +_dereq_('./timers.js')(Promise, INTERNAL, debug); +_dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); +_dereq_('./nodeify.js')(Promise); +_dereq_('./promisify.js')(Promise, INTERNAL); +_dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); +_dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); +_dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); +_dereq_('./settle.js')(Promise, PromiseArray, debug); +_dereq_('./some.js')(Promise, PromiseArray, apiRejection); +_dereq_('./filter.js')(Promise, INTERNAL); +_dereq_('./each.js')(Promise, INTERNAL); +_dereq_('./any.js')(Promise); + + util.toFastProperties(Promise); + util.toFastProperties(Promise.prototype); + function fillTypes(value) { + var p = new Promise(INTERNAL); + p._fulfillmentHandler0 = value; + p._rejectionHandler0 = value; + p._promise0 = value; + p._receiver0 = value; + } + // Complete slack tracking, opt out of field-type tracking and + // stabilize map + fillTypes({a: 1}); + fillTypes({b: 2}); + fillTypes({c: 3}); + fillTypes(1); + fillTypes(function(){}); + fillTypes(undefined); + fillTypes(false); + fillTypes(new Promise(INTERNAL)); + debug.setBounds(Async.firstLineError, util.lastLineError); + return Promise; + +}; + +},{"./any.js":1,"./async":2,"./bind":3,"./call_get.js":5,"./cancel":6,"./catch_filter":7,"./context":8,"./debuggability":9,"./direct_resolve":10,"./each.js":11,"./errors":12,"./es5":13,"./filter.js":14,"./finally":15,"./generators.js":16,"./join":17,"./map.js":18,"./method":19,"./nodeback":20,"./nodeify.js":21,"./promise_array":23,"./promisify.js":24,"./props.js":25,"./race.js":27,"./reduce.js":28,"./settle.js":30,"./some.js":31,"./synchronous_inspection":32,"./thenables":33,"./timers.js":34,"./using.js":35,"./util":36}],23:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL, tryConvertToPromise, + apiRejection, Proxyable) { +var util = _dereq_("./util"); +var isArray = util.isArray; + +function toResolutionValue(val) { + switch(val) { + case -2: return []; + case -3: return {}; + case -6: return new Map(); + } +} + +function PromiseArray(values) { + var promise = this._promise = new Promise(INTERNAL); + if (values instanceof Promise) { + promise._propagateFrom(values, 3); + } + promise._setOnCancel(this); + this._values = values; + this._length = 0; + this._totalResolved = 0; + this._init(undefined, -2); +} +util.inherits(PromiseArray, Proxyable); + +PromiseArray.prototype.length = function () { + return this._length; +}; + +PromiseArray.prototype.promise = function () { + return this._promise; +}; + +PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) { + var values = tryConvertToPromise(this._values, this._promise); + if (values instanceof Promise) { + values = values._target(); + var bitField = values._bitField; + ; + this._values = values; + + if (((bitField & 50397184) === 0)) { + this._promise._setAsyncGuaranteed(); + return values._then( + init, + this._reject, + undefined, + this, + resolveValueIfEmpty + ); + } else if (((bitField & 33554432) !== 0)) { + values = values._value(); + } else if (((bitField & 16777216) !== 0)) { + return this._reject(values._reason()); + } else { + return this._cancel(); + } + } + values = util.asArray(values); + if (values === null) { + var err = apiRejection( + "expecting an array or an iterable object but got " + util.classString(values)).reason(); + this._promise._rejectCallback(err, false); + return; + } + + if (values.length === 0) { + if (resolveValueIfEmpty === -5) { + this._resolveEmptyArray(); + } + else { + this._resolve(toResolutionValue(resolveValueIfEmpty)); + } + return; + } + this._iterate(values); +}; + +PromiseArray.prototype._iterate = function(values) { + var len = this.getActualLength(values.length); + this._length = len; + this._values = this.shouldCopyValues() ? new Array(len) : this._values; + var result = this._promise; + var isResolved = false; + var bitField = null; + for (var i = 0; i < len; ++i) { + var maybePromise = tryConvertToPromise(values[i], result); + + if (maybePromise instanceof Promise) { + maybePromise = maybePromise._target(); + bitField = maybePromise._bitField; + } else { + bitField = null; + } + + if (isResolved) { + if (bitField !== null) { + maybePromise.suppressUnhandledRejections(); + } + } else if (bitField !== null) { + if (((bitField & 50397184) === 0)) { + maybePromise._proxy(this, i); + this._values[i] = maybePromise; + } else if (((bitField & 33554432) !== 0)) { + isResolved = this._promiseFulfilled(maybePromise._value(), i); + } else if (((bitField & 16777216) !== 0)) { + isResolved = this._promiseRejected(maybePromise._reason(), i); + } else { + isResolved = this._promiseCancelled(i); + } + } else { + isResolved = this._promiseFulfilled(maybePromise, i); + } + } + if (!isResolved) result._setAsyncGuaranteed(); +}; + +PromiseArray.prototype._isResolved = function () { + return this._values === null; +}; + +PromiseArray.prototype._resolve = function (value) { + this._values = null; + this._promise._fulfill(value); +}; + +PromiseArray.prototype._cancel = function() { + if (this._isResolved() || !this._promise._isCancellable()) return; + this._values = null; + this._promise._cancel(); +}; + +PromiseArray.prototype._reject = function (reason) { + this._values = null; + this._promise._rejectCallback(reason, false); +}; + +PromiseArray.prototype._promiseFulfilled = function (value, index) { + this._values[index] = value; + var totalResolved = ++this._totalResolved; + if (totalResolved >= this._length) { + this._resolve(this._values); + return true; + } + return false; +}; + +PromiseArray.prototype._promiseCancelled = function() { + this._cancel(); + return true; +}; + +PromiseArray.prototype._promiseRejected = function (reason) { + this._totalResolved++; + this._reject(reason); + return true; +}; + +PromiseArray.prototype._resultCancelled = function() { + if (this._isResolved()) return; + var values = this._values; + this._cancel(); + if (values instanceof Promise) { + values.cancel(); + } else { + for (var i = 0; i < values.length; ++i) { + if (values[i] instanceof Promise) { + values[i].cancel(); + } + } + } +}; + +PromiseArray.prototype.shouldCopyValues = function () { + return true; +}; + +PromiseArray.prototype.getActualLength = function (len) { + return len; +}; + +return PromiseArray; +}; + +},{"./util":36}],24:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL) { +var THIS = {}; +var util = _dereq_("./util"); +var nodebackForPromise = _dereq_("./nodeback"); +var withAppended = util.withAppended; +var maybeWrapAsError = util.maybeWrapAsError; +var canEvaluate = util.canEvaluate; +var TypeError = _dereq_("./errors").TypeError; +var defaultSuffix = "Async"; +var defaultPromisified = {__isPromisified__: true}; +var noCopyProps = [ + "arity", "length", + "name", + "arguments", + "caller", + "callee", + "prototype", + "__isPromisified__" +]; +var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$"); + +var defaultFilter = function(name) { + return util.isIdentifier(name) && + name.charAt(0) !== "_" && + name !== "constructor"; +}; + +function propsFilter(key) { + return !noCopyPropsPattern.test(key); +} + +function isPromisified(fn) { + try { + return fn.__isPromisified__ === true; + } + catch (e) { + return false; + } +} + +function hasPromisified(obj, key, suffix) { + var val = util.getDataPropertyOrDefault(obj, key + suffix, + defaultPromisified); + return val ? isPromisified(val) : false; +} +function checkValid(ret, suffix, suffixRegexp) { + for (var i = 0; i < ret.length; i += 2) { + var key = ret[i]; + if (suffixRegexp.test(key)) { + var keyWithoutAsyncSuffix = key.replace(suffixRegexp, ""); + for (var j = 0; j < ret.length; j += 2) { + if (ret[j] === keyWithoutAsyncSuffix) { + throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a See http://goo.gl/MqrFmX\u000a" + .replace("%s", suffix)); + } + } + } + } +} + +function promisifiableMethods(obj, suffix, suffixRegexp, filter) { + var keys = util.inheritedDataKeys(obj); + var ret = []; + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + var value = obj[key]; + var passesDefaultFilter = filter === defaultFilter + ? true : defaultFilter(key, value, obj); + if (typeof value === "function" && + !isPromisified(value) && + !hasPromisified(obj, key, suffix) && + filter(key, value, obj, passesDefaultFilter)) { + ret.push(key, value); + } + } + checkValid(ret, suffix, suffixRegexp); + return ret; +} + +var escapeIdentRegex = function(str) { + return str.replace(/([$])/, "\\$"); +}; + +var makeNodePromisifiedEval; +if (!true) { +var switchCaseArgumentOrder = function(likelyArgumentCount) { + var ret = [likelyArgumentCount]; + var min = Math.max(0, likelyArgumentCount - 1 - 3); + for(var i = likelyArgumentCount - 1; i >= min; --i) { + ret.push(i); + } + for(var i = likelyArgumentCount + 1; i <= 3; ++i) { + ret.push(i); + } + return ret; +}; + +var argumentSequence = function(argumentCount) { + return util.filledRange(argumentCount, "_arg", ""); +}; + +var parameterDeclaration = function(parameterCount) { + return util.filledRange( + Math.max(parameterCount, 3), "_arg", ""); +}; + +var parameterCount = function(fn) { + if (typeof fn.length === "number") { + return Math.max(Math.min(fn.length, 1023 + 1), 0); + } + return 0; +}; + +makeNodePromisifiedEval = +function(callback, receiver, originalName, fn, _, multiArgs) { + var newParameterCount = Math.max(0, parameterCount(fn) - 1); + var argumentOrder = switchCaseArgumentOrder(newParameterCount); + var shouldProxyThis = typeof callback === "string" || receiver === THIS; + + function generateCallForArgumentCount(count) { + var args = argumentSequence(count).join(", "); + var comma = count > 0 ? ", " : ""; + var ret; + if (shouldProxyThis) { + ret = "ret = callback.call(this, {{args}}, nodeback); break;\n"; + } else { + ret = receiver === undefined + ? "ret = callback({{args}}, nodeback); break;\n" + : "ret = callback.call(receiver, {{args}}, nodeback); break;\n"; + } + return ret.replace("{{args}}", args).replace(", ", comma); + } + + function generateArgumentSwitchCase() { + var ret = ""; + for (var i = 0; i < argumentOrder.length; ++i) { + ret += "case " + argumentOrder[i] +":" + + generateCallForArgumentCount(argumentOrder[i]); + } + + ret += " \n\ + default: \n\ + var args = new Array(len + 1); \n\ + var i = 0; \n\ + for (var i = 0; i < len; ++i) { \n\ + args[i] = arguments[i]; \n\ + } \n\ + args[i] = nodeback; \n\ + [CodeForCall] \n\ + break; \n\ + ".replace("[CodeForCall]", (shouldProxyThis + ? "ret = callback.apply(this, args);\n" + : "ret = callback.apply(receiver, args);\n")); + return ret; + } + + var getFunctionCode = typeof callback === "string" + ? ("this != null ? this['"+callback+"'] : fn") + : "fn"; + var body = "'use strict'; \n\ + var ret = function (Parameters) { \n\ + 'use strict'; \n\ + var len = arguments.length; \n\ + var promise = new Promise(INTERNAL); \n\ + promise._captureStackTrace(); \n\ + var nodeback = nodebackForPromise(promise, " + multiArgs + "); \n\ + var ret; \n\ + var callback = tryCatch([GetFunctionCode]); \n\ + switch(len) { \n\ + [CodeForSwitchCase] \n\ + } \n\ + if (ret === errorObj) { \n\ + promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\ + } \n\ + if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); \n\ + return promise; \n\ + }; \n\ + notEnumerableProp(ret, '__isPromisified__', true); \n\ + return ret; \n\ + ".replace("[CodeForSwitchCase]", generateArgumentSwitchCase()) + .replace("[GetFunctionCode]", getFunctionCode); + body = body.replace("Parameters", parameterDeclaration(newParameterCount)); + return new Function("Promise", + "fn", + "receiver", + "withAppended", + "maybeWrapAsError", + "nodebackForPromise", + "tryCatch", + "errorObj", + "notEnumerableProp", + "INTERNAL", + body)( + Promise, + fn, + receiver, + withAppended, + maybeWrapAsError, + nodebackForPromise, + util.tryCatch, + util.errorObj, + util.notEnumerableProp, + INTERNAL); +}; +} + +function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) { + var defaultThis = (function() {return this;})(); + var method = callback; + if (typeof method === "string") { + callback = fn; + } + function promisified() { + var _receiver = receiver; + if (receiver === THIS) _receiver = this; + var promise = new Promise(INTERNAL); + promise._captureStackTrace(); + var cb = typeof method === "string" && this !== defaultThis + ? this[method] : callback; + var fn = nodebackForPromise(promise, multiArgs); + try { + cb.apply(_receiver, withAppended(arguments, fn)); + } catch(e) { + promise._rejectCallback(maybeWrapAsError(e), true, true); + } + if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); + return promise; + } + util.notEnumerableProp(promisified, "__isPromisified__", true); + return promisified; +} + +var makeNodePromisified = canEvaluate + ? makeNodePromisifiedEval + : makeNodePromisifiedClosure; + +function promisifyAll(obj, suffix, filter, promisifier, multiArgs) { + var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$"); + var methods = + promisifiableMethods(obj, suffix, suffixRegexp, filter); + + for (var i = 0, len = methods.length; i < len; i+= 2) { + var key = methods[i]; + var fn = methods[i+1]; + var promisifiedKey = key + suffix; + if (promisifier === makeNodePromisified) { + obj[promisifiedKey] = + makeNodePromisified(key, THIS, key, fn, suffix, multiArgs); + } else { + var promisified = promisifier(fn, function() { + return makeNodePromisified(key, THIS, key, + fn, suffix, multiArgs); + }); + util.notEnumerableProp(promisified, "__isPromisified__", true); + obj[promisifiedKey] = promisified; + } + } + util.toFastProperties(obj); + return obj; +} + +function promisify(callback, receiver, multiArgs) { + return makeNodePromisified(callback, receiver, undefined, + callback, null, multiArgs); +} + +Promise.promisify = function (fn, options) { + if (typeof fn !== "function") { + throw new TypeError("expecting a function but got " + util.classString(fn)); + } + if (isPromisified(fn)) { + return fn; + } + options = Object(options); + var receiver = options.context === undefined ? THIS : options.context; + var multiArgs = !!options.multiArgs; + var ret = promisify(fn, receiver, multiArgs); + util.copyDescriptors(fn, ret, propsFilter); + return ret; +}; + +Promise.promisifyAll = function (target, options) { + if (typeof target !== "function" && typeof target !== "object") { + throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + options = Object(options); + var multiArgs = !!options.multiArgs; + var suffix = options.suffix; + if (typeof suffix !== "string") suffix = defaultSuffix; + var filter = options.filter; + if (typeof filter !== "function") filter = defaultFilter; + var promisifier = options.promisifier; + if (typeof promisifier !== "function") promisifier = makeNodePromisified; + + if (!util.isIdentifier(suffix)) { + throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + + var keys = util.inheritedDataKeys(target); + for (var i = 0; i < keys.length; ++i) { + var value = target[keys[i]]; + if (keys[i] !== "constructor" && + util.isClass(value)) { + promisifyAll(value.prototype, suffix, filter, promisifier, + multiArgs); + promisifyAll(value, suffix, filter, promisifier, multiArgs); + } + } + + return promisifyAll(target, suffix, filter, promisifier, multiArgs); +}; +}; + + +},{"./errors":12,"./nodeback":20,"./util":36}],25:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function( + Promise, PromiseArray, tryConvertToPromise, apiRejection) { +var util = _dereq_("./util"); +var isObject = util.isObject; +var es5 = _dereq_("./es5"); +var Es6Map; +if (typeof Map === "function") Es6Map = Map; + +var mapToEntries = (function() { + var index = 0; + var size = 0; + + function extractEntry(value, key) { + this[index] = value; + this[index + size] = key; + index++; + } + + return function mapToEntries(map) { + size = map.size; + index = 0; + var ret = new Array(map.size * 2); + map.forEach(extractEntry, ret); + return ret; + }; +})(); + +var entriesToMap = function(entries) { + var ret = new Es6Map(); + var length = entries.length / 2 | 0; + for (var i = 0; i < length; ++i) { + var key = entries[length + i]; + var value = entries[i]; + ret.set(key, value); + } + return ret; +}; + +function PropertiesPromiseArray(obj) { + var isMap = false; + var entries; + if (Es6Map !== undefined && obj instanceof Es6Map) { + entries = mapToEntries(obj); + isMap = true; + } else { + var keys = es5.keys(obj); + var len = keys.length; + entries = new Array(len * 2); + for (var i = 0; i < len; ++i) { + var key = keys[i]; + entries[i] = obj[key]; + entries[i + len] = key; + } + } + this.constructor$(entries); + this._isMap = isMap; + this._init$(undefined, isMap ? -6 : -3); +} +util.inherits(PropertiesPromiseArray, PromiseArray); + +PropertiesPromiseArray.prototype._init = function () {}; + +PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) { + this._values[index] = value; + var totalResolved = ++this._totalResolved; + if (totalResolved >= this._length) { + var val; + if (this._isMap) { + val = entriesToMap(this._values); + } else { + val = {}; + var keyOffset = this.length(); + for (var i = 0, len = this.length(); i < len; ++i) { + val[this._values[i + keyOffset]] = this._values[i]; + } + } + this._resolve(val); + return true; + } + return false; +}; + +PropertiesPromiseArray.prototype.shouldCopyValues = function () { + return false; +}; + +PropertiesPromiseArray.prototype.getActualLength = function (len) { + return len >> 1; +}; + +function props(promises) { + var ret; + var castValue = tryConvertToPromise(promises); + + if (!isObject(castValue)) { + return apiRejection("cannot await properties of a non-object\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } else if (castValue instanceof Promise) { + ret = castValue._then( + Promise.props, undefined, undefined, undefined, undefined); + } else { + ret = new PropertiesPromiseArray(castValue).promise(); + } + + if (castValue instanceof Promise) { + ret._propagateFrom(castValue, 2); + } + return ret; +} + +Promise.prototype.props = function () { + return props(this); +}; + +Promise.props = function (promises) { + return props(promises); +}; +}; + +},{"./es5":13,"./util":36}],26:[function(_dereq_,module,exports){ +"use strict"; +function arrayMove(src, srcIndex, dst, dstIndex, len) { + for (var j = 0; j < len; ++j) { + dst[j + dstIndex] = src[j + srcIndex]; + src[j + srcIndex] = void 0; + } +} + +function Queue(capacity) { + this._capacity = capacity; + this._length = 0; + this._front = 0; +} + +Queue.prototype._willBeOverCapacity = function (size) { + return this._capacity < size; +}; + +Queue.prototype._pushOne = function (arg) { + var length = this.length(); + this._checkCapacity(length + 1); + var i = (this._front + length) & (this._capacity - 1); + this[i] = arg; + this._length = length + 1; +}; + +Queue.prototype.push = function (fn, receiver, arg) { + var length = this.length() + 3; + if (this._willBeOverCapacity(length)) { + this._pushOne(fn); + this._pushOne(receiver); + this._pushOne(arg); + return; + } + var j = this._front + length - 3; + this._checkCapacity(length); + var wrapMask = this._capacity - 1; + this[(j + 0) & wrapMask] = fn; + this[(j + 1) & wrapMask] = receiver; + this[(j + 2) & wrapMask] = arg; + this._length = length; +}; + +Queue.prototype.shift = function () { + var front = this._front, + ret = this[front]; + + this[front] = undefined; + this._front = (front + 1) & (this._capacity - 1); + this._length--; + return ret; +}; + +Queue.prototype.length = function () { + return this._length; +}; + +Queue.prototype._checkCapacity = function (size) { + if (this._capacity < size) { + this._resizeTo(this._capacity << 1); + } +}; + +Queue.prototype._resizeTo = function (capacity) { + var oldCapacity = this._capacity; + this._capacity = capacity; + var front = this._front; + var length = this._length; + var moveItemsCount = (front + length) & (oldCapacity - 1); + arrayMove(this, 0, this, oldCapacity, moveItemsCount); +}; + +module.exports = Queue; + +},{}],27:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function( + Promise, INTERNAL, tryConvertToPromise, apiRejection) { +var util = _dereq_("./util"); + +var raceLater = function (promise) { + return promise.then(function(array) { + return race(array, promise); + }); +}; + +function race(promises, parent) { + var maybePromise = tryConvertToPromise(promises); + + if (maybePromise instanceof Promise) { + return raceLater(maybePromise); + } else { + promises = util.asArray(promises); + if (promises === null) + return apiRejection("expecting an array or an iterable object but got " + util.classString(promises)); + } + + var ret = new Promise(INTERNAL); + if (parent !== undefined) { + ret._propagateFrom(parent, 3); + } + var fulfill = ret._fulfill; + var reject = ret._reject; + for (var i = 0, len = promises.length; i < len; ++i) { + var val = promises[i]; + + if (val === undefined && !(i in promises)) { + continue; + } + + Promise.cast(val)._then(fulfill, reject, undefined, ret, null); + } + return ret; +} + +Promise.race = function (promises) { + return race(promises, undefined); +}; + +Promise.prototype.race = function () { + return race(this, undefined); +}; + +}; + +},{"./util":36}],28:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, + PromiseArray, + apiRejection, + tryConvertToPromise, + INTERNAL, + debug) { +var getDomain = Promise._getDomain; +var util = _dereq_("./util"); +var tryCatch = util.tryCatch; + +function ReductionPromiseArray(promises, fn, initialValue, _each) { + this.constructor$(promises); + var domain = getDomain(); + this._fn = domain === null ? fn : util.domainBind(domain, fn); + if (initialValue !== undefined) { + initialValue = Promise.resolve(initialValue); + initialValue._attachCancellationCallback(this); + } + this._initialValue = initialValue; + this._currentCancellable = null; + if(_each === INTERNAL) { + this._eachValues = Array(this._length); + } else if (_each === 0) { + this._eachValues = null; + } else { + this._eachValues = undefined; + } + this._promise._captureStackTrace(); + this._init$(undefined, -5); +} +util.inherits(ReductionPromiseArray, PromiseArray); + +ReductionPromiseArray.prototype._gotAccum = function(accum) { + if (this._eachValues !== undefined && + this._eachValues !== null && + accum !== INTERNAL) { + this._eachValues.push(accum); + } +}; + +ReductionPromiseArray.prototype._eachComplete = function(value) { + if (this._eachValues !== null) { + this._eachValues.push(value); + } + return this._eachValues; +}; + +ReductionPromiseArray.prototype._init = function() {}; + +ReductionPromiseArray.prototype._resolveEmptyArray = function() { + this._resolve(this._eachValues !== undefined ? this._eachValues + : this._initialValue); +}; + +ReductionPromiseArray.prototype.shouldCopyValues = function () { + return false; +}; + +ReductionPromiseArray.prototype._resolve = function(value) { + this._promise._resolveCallback(value); + this._values = null; +}; + +ReductionPromiseArray.prototype._resultCancelled = function(sender) { + if (sender === this._initialValue) return this._cancel(); + if (this._isResolved()) return; + this._resultCancelled$(); + if (this._currentCancellable instanceof Promise) { + this._currentCancellable.cancel(); + } + if (this._initialValue instanceof Promise) { + this._initialValue.cancel(); + } +}; + +ReductionPromiseArray.prototype._iterate = function (values) { + this._values = values; + var value; + var i; + var length = values.length; + if (this._initialValue !== undefined) { + value = this._initialValue; + i = 0; + } else { + value = Promise.resolve(values[0]); + i = 1; + } + + this._currentCancellable = value; + + if (!value.isRejected()) { + for (; i < length; ++i) { + var ctx = { + accum: null, + value: values[i], + index: i, + length: length, + array: this + }; + value = value._then(gotAccum, undefined, undefined, ctx, undefined); + } + } + + if (this._eachValues !== undefined) { + value = value + ._then(this._eachComplete, undefined, undefined, this, undefined); + } + value._then(completed, completed, undefined, value, this); +}; + +Promise.prototype.reduce = function (fn, initialValue) { + return reduce(this, fn, initialValue, null); +}; + +Promise.reduce = function (promises, fn, initialValue, _each) { + return reduce(promises, fn, initialValue, _each); +}; + +function completed(valueOrReason, array) { + if (this.isFulfilled()) { + array._resolve(valueOrReason); + } else { + array._reject(valueOrReason); + } +} + +function reduce(promises, fn, initialValue, _each) { + if (typeof fn !== "function") { + return apiRejection("expecting a function but got " + util.classString(fn)); + } + var array = new ReductionPromiseArray(promises, fn, initialValue, _each); + return array.promise(); +} + +function gotAccum(accum) { + this.accum = accum; + this.array._gotAccum(accum); + var value = tryConvertToPromise(this.value, this.array._promise); + if (value instanceof Promise) { + this.array._currentCancellable = value; + return value._then(gotValue, undefined, undefined, this, undefined); + } else { + return gotValue.call(this, value); + } +} + +function gotValue(value) { + var array = this.array; + var promise = array._promise; + var fn = tryCatch(array._fn); + promise._pushContext(); + var ret; + if (array._eachValues !== undefined) { + ret = fn.call(promise._boundValue(), value, this.index, this.length); + } else { + ret = fn.call(promise._boundValue(), + this.accum, value, this.index, this.length); + } + if (ret instanceof Promise) { + array._currentCancellable = ret; + } + var promiseCreated = promise._popContext(); + debug.checkForgottenReturns( + ret, + promiseCreated, + array._eachValues !== undefined ? "Promise.each" : "Promise.reduce", + promise + ); + return ret; +} +}; + +},{"./util":36}],29:[function(_dereq_,module,exports){ +"use strict"; +var util = _dereq_("./util"); +var schedule; +var noAsyncScheduler = function() { + throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a"); +}; +var NativePromise = util.getNativePromise(); +if (util.isNode && typeof MutationObserver === "undefined") { + var GlobalSetImmediate = global.setImmediate; + var ProcessNextTick = process.nextTick; + schedule = util.isRecentNode + ? function(fn) { GlobalSetImmediate.call(global, fn); } + : function(fn) { ProcessNextTick.call(process, fn); }; +} else if (typeof NativePromise === "function" && + typeof NativePromise.resolve === "function") { + var nativePromise = NativePromise.resolve(); + schedule = function(fn) { + nativePromise.then(fn); + }; +} else if ((typeof MutationObserver !== "undefined") && + !(typeof window !== "undefined" && + window.navigator && + (window.navigator.standalone || window.cordova))) { + schedule = (function() { + var div = document.createElement("div"); + var opts = {attributes: true}; + var toggleScheduled = false; + var div2 = document.createElement("div"); + var o2 = new MutationObserver(function() { + div.classList.toggle("foo"); + toggleScheduled = false; + }); + o2.observe(div2, opts); + + var scheduleToggle = function() { + if (toggleScheduled) return; + toggleScheduled = true; + div2.classList.toggle("foo"); + }; + + return function schedule(fn) { + var o = new MutationObserver(function() { + o.disconnect(); + fn(); + }); + o.observe(div, opts); + scheduleToggle(); + }; + })(); +} else if (typeof setImmediate !== "undefined") { + schedule = function (fn) { + setImmediate(fn); + }; +} else if (typeof setTimeout !== "undefined") { + schedule = function (fn) { + setTimeout(fn, 0); + }; +} else { + schedule = noAsyncScheduler; +} +module.exports = schedule; + +},{"./util":36}],30:[function(_dereq_,module,exports){ +"use strict"; +module.exports = + function(Promise, PromiseArray, debug) { +var PromiseInspection = Promise.PromiseInspection; +var util = _dereq_("./util"); + +function SettledPromiseArray(values) { + this.constructor$(values); +} +util.inherits(SettledPromiseArray, PromiseArray); + +SettledPromiseArray.prototype._promiseResolved = function (index, inspection) { + this._values[index] = inspection; + var totalResolved = ++this._totalResolved; + if (totalResolved >= this._length) { + this._resolve(this._values); + return true; + } + return false; +}; + +SettledPromiseArray.prototype._promiseFulfilled = function (value, index) { + var ret = new PromiseInspection(); + ret._bitField = 33554432; + ret._settledValueField = value; + return this._promiseResolved(index, ret); +}; +SettledPromiseArray.prototype._promiseRejected = function (reason, index) { + var ret = new PromiseInspection(); + ret._bitField = 16777216; + ret._settledValueField = reason; + return this._promiseResolved(index, ret); +}; + +Promise.settle = function (promises) { + debug.deprecated(".settle()", ".reflect()"); + return new SettledPromiseArray(promises).promise(); +}; + +Promise.prototype.settle = function () { + return Promise.settle(this); +}; +}; + +},{"./util":36}],31:[function(_dereq_,module,exports){ +"use strict"; +module.exports = +function(Promise, PromiseArray, apiRejection) { +var util = _dereq_("./util"); +var RangeError = _dereq_("./errors").RangeError; +var AggregateError = _dereq_("./errors").AggregateError; +var isArray = util.isArray; +var CANCELLATION = {}; + + +function SomePromiseArray(values) { + this.constructor$(values); + this._howMany = 0; + this._unwrap = false; + this._initialized = false; +} +util.inherits(SomePromiseArray, PromiseArray); + +SomePromiseArray.prototype._init = function () { + if (!this._initialized) { + return; + } + if (this._howMany === 0) { + this._resolve([]); + return; + } + this._init$(undefined, -5); + var isArrayResolved = isArray(this._values); + if (!this._isResolved() && + isArrayResolved && + this._howMany > this._canPossiblyFulfill()) { + this._reject(this._getRangeError(this.length())); + } +}; + +SomePromiseArray.prototype.init = function () { + this._initialized = true; + this._init(); +}; + +SomePromiseArray.prototype.setUnwrap = function () { + this._unwrap = true; +}; + +SomePromiseArray.prototype.howMany = function () { + return this._howMany; +}; + +SomePromiseArray.prototype.setHowMany = function (count) { + this._howMany = count; +}; + +SomePromiseArray.prototype._promiseFulfilled = function (value) { + this._addFulfilled(value); + if (this._fulfilled() === this.howMany()) { + this._values.length = this.howMany(); + if (this.howMany() === 1 && this._unwrap) { + this._resolve(this._values[0]); + } else { + this._resolve(this._values); + } + return true; + } + return false; + +}; +SomePromiseArray.prototype._promiseRejected = function (reason) { + this._addRejected(reason); + return this._checkOutcome(); +}; + +SomePromiseArray.prototype._promiseCancelled = function () { + if (this._values instanceof Promise || this._values == null) { + return this._cancel(); + } + this._addRejected(CANCELLATION); + return this._checkOutcome(); +}; + +SomePromiseArray.prototype._checkOutcome = function() { + if (this.howMany() > this._canPossiblyFulfill()) { + var e = new AggregateError(); + for (var i = this.length(); i < this._values.length; ++i) { + if (this._values[i] !== CANCELLATION) { + e.push(this._values[i]); + } + } + if (e.length > 0) { + this._reject(e); + } else { + this._cancel(); + } + return true; + } + return false; +}; + +SomePromiseArray.prototype._fulfilled = function () { + return this._totalResolved; +}; + +SomePromiseArray.prototype._rejected = function () { + return this._values.length - this.length(); +}; + +SomePromiseArray.prototype._addRejected = function (reason) { + this._values.push(reason); +}; + +SomePromiseArray.prototype._addFulfilled = function (value) { + this._values[this._totalResolved++] = value; +}; + +SomePromiseArray.prototype._canPossiblyFulfill = function () { + return this.length() - this._rejected(); +}; + +SomePromiseArray.prototype._getRangeError = function (count) { + var message = "Input array must contain at least " + + this._howMany + " items but contains only " + count + " items"; + return new RangeError(message); +}; + +SomePromiseArray.prototype._resolveEmptyArray = function () { + this._reject(this._getRangeError(0)); +}; + +function some(promises, howMany) { + if ((howMany | 0) !== howMany || howMany < 0) { + return apiRejection("expecting a positive integer\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + var ret = new SomePromiseArray(promises); + var promise = ret.promise(); + ret.setHowMany(howMany); + ret.init(); + return promise; +} + +Promise.some = function (promises, howMany) { + return some(promises, howMany); +}; + +Promise.prototype.some = function (howMany) { + return some(this, howMany); +}; + +Promise._SomePromiseArray = SomePromiseArray; +}; + +},{"./errors":12,"./util":36}],32:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise) { +function PromiseInspection(promise) { + if (promise !== undefined) { + promise = promise._target(); + this._bitField = promise._bitField; + this._settledValueField = promise._isFateSealed() + ? promise._settledValue() : undefined; + } + else { + this._bitField = 0; + this._settledValueField = undefined; + } +} + +PromiseInspection.prototype._settledValue = function() { + return this._settledValueField; +}; + +var value = PromiseInspection.prototype.value = function () { + if (!this.isFulfilled()) { + throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + return this._settledValue(); +}; + +var reason = PromiseInspection.prototype.error = +PromiseInspection.prototype.reason = function () { + if (!this.isRejected()) { + throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/MqrFmX\u000a"); + } + return this._settledValue(); +}; + +var isFulfilled = PromiseInspection.prototype.isFulfilled = function() { + return (this._bitField & 33554432) !== 0; +}; + +var isRejected = PromiseInspection.prototype.isRejected = function () { + return (this._bitField & 16777216) !== 0; +}; + +var isPending = PromiseInspection.prototype.isPending = function () { + return (this._bitField & 50397184) === 0; +}; + +var isResolved = PromiseInspection.prototype.isResolved = function () { + return (this._bitField & 50331648) !== 0; +}; + +PromiseInspection.prototype.isCancelled = function() { + return (this._bitField & 8454144) !== 0; +}; + +Promise.prototype.__isCancelled = function() { + return (this._bitField & 65536) === 65536; +}; + +Promise.prototype._isCancelled = function() { + return this._target().__isCancelled(); +}; + +Promise.prototype.isCancelled = function() { + return (this._target()._bitField & 8454144) !== 0; +}; + +Promise.prototype.isPending = function() { + return isPending.call(this._target()); +}; + +Promise.prototype.isRejected = function() { + return isRejected.call(this._target()); +}; + +Promise.prototype.isFulfilled = function() { + return isFulfilled.call(this._target()); +}; + +Promise.prototype.isResolved = function() { + return isResolved.call(this._target()); +}; + +Promise.prototype.value = function() { + return value.call(this._target()); +}; + +Promise.prototype.reason = function() { + var target = this._target(); + target._unsetRejectionIsUnhandled(); + return reason.call(target); +}; + +Promise.prototype._value = function() { + return this._settledValue(); +}; + +Promise.prototype._reason = function() { + this._unsetRejectionIsUnhandled(); + return this._settledValue(); +}; + +Promise.PromiseInspection = PromiseInspection; +}; + +},{}],33:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL) { +var util = _dereq_("./util"); +var errorObj = util.errorObj; +var isObject = util.isObject; + +function tryConvertToPromise(obj, context) { + if (isObject(obj)) { + if (obj instanceof Promise) return obj; + var then = getThen(obj); + if (then === errorObj) { + if (context) context._pushContext(); + var ret = Promise.reject(then.e); + if (context) context._popContext(); + return ret; + } else if (typeof then === "function") { + if (isAnyBluebirdPromise(obj)) { + var ret = new Promise(INTERNAL); + obj._then( + ret._fulfill, + ret._reject, + undefined, + ret, + null + ); + return ret; + } + return doThenable(obj, then, context); + } + } + return obj; +} + +function doGetThen(obj) { + return obj.then; +} + +function getThen(obj) { + try { + return doGetThen(obj); + } catch (e) { + errorObj.e = e; + return errorObj; + } +} + +var hasProp = {}.hasOwnProperty; +function isAnyBluebirdPromise(obj) { + try { + return hasProp.call(obj, "_promise0"); + } catch (e) { + return false; + } +} + +function doThenable(x, then, context) { + var promise = new Promise(INTERNAL); + var ret = promise; + if (context) context._pushContext(); + promise._captureStackTrace(); + if (context) context._popContext(); + var synchronous = true; + var result = util.tryCatch(then).call(x, resolve, reject); + synchronous = false; + + if (promise && result === errorObj) { + promise._rejectCallback(result.e, true, true); + promise = null; + } + + function resolve(value) { + if (!promise) return; + promise._resolveCallback(value); + promise = null; + } + + function reject(reason) { + if (!promise) return; + promise._rejectCallback(reason, synchronous, true); + promise = null; + } + return ret; +} + +return tryConvertToPromise; +}; + +},{"./util":36}],34:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function(Promise, INTERNAL, debug) { +var util = _dereq_("./util"); +var TimeoutError = Promise.TimeoutError; + +function HandleWrapper(handle) { + this.handle = handle; +} + +HandleWrapper.prototype._resultCancelled = function() { + clearTimeout(this.handle); +}; + +var afterValue = function(value) { return delay(+this).thenReturn(value); }; +var delay = Promise.delay = function (ms, value) { + var ret; + var handle; + if (value !== undefined) { + ret = Promise.resolve(value) + ._then(afterValue, null, null, ms, undefined); + if (debug.cancellation() && value instanceof Promise) { + ret._setOnCancel(value); + } + } else { + ret = new Promise(INTERNAL); + handle = setTimeout(function() { ret._fulfill(); }, +ms); + if (debug.cancellation()) { + ret._setOnCancel(new HandleWrapper(handle)); + } + ret._captureStackTrace(); + } + ret._setAsyncGuaranteed(); + return ret; +}; + +Promise.prototype.delay = function (ms) { + return delay(ms, this); +}; + +var afterTimeout = function (promise, message, parent) { + var err; + if (typeof message !== "string") { + if (message instanceof Error) { + err = message; + } else { + err = new TimeoutError("operation timed out"); + } + } else { + err = new TimeoutError(message); + } + util.markAsOriginatingFromRejection(err); + promise._attachExtraTrace(err); + promise._reject(err); + + if (parent != null) { + parent.cancel(); + } +}; + +function successClear(value) { + clearTimeout(this.handle); + return value; +} + +function failureClear(reason) { + clearTimeout(this.handle); + throw reason; +} + +Promise.prototype.timeout = function (ms, message) { + ms = +ms; + var ret, parent; + + var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() { + if (ret.isPending()) { + afterTimeout(ret, message, parent); + } + }, ms)); + + if (debug.cancellation()) { + parent = this.then(); + ret = parent._then(successClear, failureClear, + undefined, handleWrapper, undefined); + ret._setOnCancel(handleWrapper); + } else { + ret = this._then(successClear, failureClear, + undefined, handleWrapper, undefined); + } + + return ret; +}; + +}; + +},{"./util":36}],35:[function(_dereq_,module,exports){ +"use strict"; +module.exports = function (Promise, apiRejection, tryConvertToPromise, + createContext, INTERNAL, debug) { + var util = _dereq_("./util"); + var TypeError = _dereq_("./errors").TypeError; + var inherits = _dereq_("./util").inherits; + var errorObj = util.errorObj; + var tryCatch = util.tryCatch; + var NULL = {}; + + function thrower(e) { + setTimeout(function(){throw e;}, 0); + } + + function castPreservingDisposable(thenable) { + var maybePromise = tryConvertToPromise(thenable); + if (maybePromise !== thenable && + typeof thenable._isDisposable === "function" && + typeof thenable._getDisposer === "function" && + thenable._isDisposable()) { + maybePromise._setDisposable(thenable._getDisposer()); + } + return maybePromise; + } + function dispose(resources, inspection) { + var i = 0; + var len = resources.length; + var ret = new Promise(INTERNAL); + function iterator() { + if (i >= len) return ret._fulfill(); + var maybePromise = castPreservingDisposable(resources[i++]); + if (maybePromise instanceof Promise && + maybePromise._isDisposable()) { + try { + maybePromise = tryConvertToPromise( + maybePromise._getDisposer().tryDispose(inspection), + resources.promise); + } catch (e) { + return thrower(e); + } + if (maybePromise instanceof Promise) { + return maybePromise._then(iterator, thrower, + null, null, null); + } + } + iterator(); + } + iterator(); + return ret; + } + + function Disposer(data, promise, context) { + this._data = data; + this._promise = promise; + this._context = context; + } + + Disposer.prototype.data = function () { + return this._data; + }; + + Disposer.prototype.promise = function () { + return this._promise; + }; + + Disposer.prototype.resource = function () { + if (this.promise().isFulfilled()) { + return this.promise().value(); + } + return NULL; + }; + + Disposer.prototype.tryDispose = function(inspection) { + var resource = this.resource(); + var context = this._context; + if (context !== undefined) context._pushContext(); + var ret = resource !== NULL + ? this.doDispose(resource, inspection) : null; + if (context !== undefined) context._popContext(); + this._promise._unsetDisposable(); + this._data = null; + return ret; + }; + + Disposer.isDisposer = function (d) { + return (d != null && + typeof d.resource === "function" && + typeof d.tryDispose === "function"); + }; + + function FunctionDisposer(fn, promise, context) { + this.constructor$(fn, promise, context); + } + inherits(FunctionDisposer, Disposer); + + FunctionDisposer.prototype.doDispose = function (resource, inspection) { + var fn = this.data(); + return fn.call(resource, resource, inspection); + }; + + function maybeUnwrapDisposer(value) { + if (Disposer.isDisposer(value)) { + this.resources[this.index]._setDisposable(value); + return value.promise(); + } + return value; + } + + function ResourceList(length) { + this.length = length; + this.promise = null; + this[length-1] = null; + } + + ResourceList.prototype._resultCancelled = function() { + var len = this.length; + for (var i = 0; i < len; ++i) { + var item = this[i]; + if (item instanceof Promise) { + item.cancel(); + } + } + }; + + Promise.using = function () { + var len = arguments.length; + if (len < 2) return apiRejection( + "you must pass at least 2 arguments to Promise.using"); + var fn = arguments[len - 1]; + if (typeof fn !== "function") { + return apiRejection("expecting a function but got " + util.classString(fn)); + } + var input; + var spreadArgs = true; + if (len === 2 && Array.isArray(arguments[0])) { + input = arguments[0]; + len = input.length; + spreadArgs = false; + } else { + input = arguments; + len--; + } + var resources = new ResourceList(len); + for (var i = 0; i < len; ++i) { + var resource = input[i]; + if (Disposer.isDisposer(resource)) { + var disposer = resource; + resource = resource.promise(); + resource._setDisposable(disposer); + } else { + var maybePromise = tryConvertToPromise(resource); + if (maybePromise instanceof Promise) { + resource = + maybePromise._then(maybeUnwrapDisposer, null, null, { + resources: resources, + index: i + }, undefined); + } + } + resources[i] = resource; + } + + var reflectedResources = new Array(resources.length); + for (var i = 0; i < reflectedResources.length; ++i) { + reflectedResources[i] = Promise.resolve(resources[i]).reflect(); + } + + var resultPromise = Promise.all(reflectedResources) + .then(function(inspections) { + for (var i = 0; i < inspections.length; ++i) { + var inspection = inspections[i]; + if (inspection.isRejected()) { + errorObj.e = inspection.error(); + return errorObj; + } else if (!inspection.isFulfilled()) { + resultPromise.cancel(); + return; + } + inspections[i] = inspection.value(); + } + promise._pushContext(); + + fn = tryCatch(fn); + var ret = spreadArgs + ? fn.apply(undefined, inspections) : fn(inspections); + var promiseCreated = promise._popContext(); + debug.checkForgottenReturns( + ret, promiseCreated, "Promise.using", promise); + return ret; + }); + + var promise = resultPromise.lastly(function() { + var inspection = new Promise.PromiseInspection(resultPromise); + return dispose(resources, inspection); + }); + resources.promise = promise; + promise._setOnCancel(resources); + return promise; + }; + + Promise.prototype._setDisposable = function (disposer) { + this._bitField = this._bitField | 131072; + this._disposer = disposer; + }; + + Promise.prototype._isDisposable = function () { + return (this._bitField & 131072) > 0; + }; + + Promise.prototype._getDisposer = function () { + return this._disposer; + }; + + Promise.prototype._unsetDisposable = function () { + this._bitField = this._bitField & (~131072); + this._disposer = undefined; + }; + + Promise.prototype.disposer = function (fn) { + if (typeof fn === "function") { + return new FunctionDisposer(fn, this, createContext()); + } + throw new TypeError(); + }; + +}; + +},{"./errors":12,"./util":36}],36:[function(_dereq_,module,exports){ +"use strict"; +var es5 = _dereq_("./es5"); +var canEvaluate = typeof navigator == "undefined"; + +var errorObj = {e: {}}; +var tryCatchTarget; +var globalObject = typeof self !== "undefined" ? self : + typeof window !== "undefined" ? window : + typeof global !== "undefined" ? global : + this !== undefined ? this : null; + +function tryCatcher() { + try { + var target = tryCatchTarget; + tryCatchTarget = null; + return target.apply(this, arguments); + } catch (e) { + errorObj.e = e; + return errorObj; + } +} +function tryCatch(fn) { + tryCatchTarget = fn; + return tryCatcher; +} + +var inherits = function(Child, Parent) { + var hasProp = {}.hasOwnProperty; + + function T() { + this.constructor = Child; + this.constructor$ = Parent; + for (var propertyName in Parent.prototype) { + if (hasProp.call(Parent.prototype, propertyName) && + propertyName.charAt(propertyName.length-1) !== "$" + ) { + this[propertyName + "$"] = Parent.prototype[propertyName]; + } + } + } + T.prototype = Parent.prototype; + Child.prototype = new T(); + return Child.prototype; +}; + + +function isPrimitive(val) { + return val == null || val === true || val === false || + typeof val === "string" || typeof val === "number"; + +} + +function isObject(value) { + return typeof value === "function" || + typeof value === "object" && value !== null; +} + +function maybeWrapAsError(maybeError) { + if (!isPrimitive(maybeError)) return maybeError; + + return new Error(safeToString(maybeError)); +} + +function withAppended(target, appendee) { + var len = target.length; + var ret = new Array(len + 1); + var i; + for (i = 0; i < len; ++i) { + ret[i] = target[i]; + } + ret[i] = appendee; + return ret; +} + +function getDataPropertyOrDefault(obj, key, defaultValue) { + if (es5.isES5) { + var desc = Object.getOwnPropertyDescriptor(obj, key); + + if (desc != null) { + return desc.get == null && desc.set == null + ? desc.value + : defaultValue; + } + } else { + return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined; + } +} + +function notEnumerableProp(obj, name, value) { + if (isPrimitive(obj)) return obj; + var descriptor = { + value: value, + configurable: true, + enumerable: false, + writable: true + }; + es5.defineProperty(obj, name, descriptor); + return obj; +} + +function thrower(r) { + throw r; +} + +var inheritedDataKeys = (function() { + var excludedPrototypes = [ + Array.prototype, + Object.prototype, + Function.prototype + ]; + + var isExcludedProto = function(val) { + for (var i = 0; i < excludedPrototypes.length; ++i) { + if (excludedPrototypes[i] === val) { + return true; + } + } + return false; + }; + + if (es5.isES5) { + var getKeys = Object.getOwnPropertyNames; + return function(obj) { + var ret = []; + var visitedKeys = Object.create(null); + while (obj != null && !isExcludedProto(obj)) { + var keys; + try { + keys = getKeys(obj); + } catch (e) { + return ret; + } + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + if (visitedKeys[key]) continue; + visitedKeys[key] = true; + var desc = Object.getOwnPropertyDescriptor(obj, key); + if (desc != null && desc.get == null && desc.set == null) { + ret.push(key); + } + } + obj = es5.getPrototypeOf(obj); + } + return ret; + }; + } else { + var hasProp = {}.hasOwnProperty; + return function(obj) { + if (isExcludedProto(obj)) return []; + var ret = []; + + /*jshint forin:false */ + enumeration: for (var key in obj) { + if (hasProp.call(obj, key)) { + ret.push(key); + } else { + for (var i = 0; i < excludedPrototypes.length; ++i) { + if (hasProp.call(excludedPrototypes[i], key)) { + continue enumeration; + } + } + ret.push(key); + } + } + return ret; + }; + } + +})(); + +var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/; +function isClass(fn) { + try { + if (typeof fn === "function") { + var keys = es5.names(fn.prototype); + + var hasMethods = es5.isES5 && keys.length > 1; + var hasMethodsOtherThanConstructor = keys.length > 0 && + !(keys.length === 1 && keys[0] === "constructor"); + var hasThisAssignmentAndStaticMethods = + thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0; + + if (hasMethods || hasMethodsOtherThanConstructor || + hasThisAssignmentAndStaticMethods) { + return true; + } + } + return false; + } catch (e) { + return false; + } +} + +function toFastProperties(obj) { + /*jshint -W027,-W055,-W031*/ + function FakeConstructor() {} + FakeConstructor.prototype = obj; + var receiver = new FakeConstructor(); + function ic() { + return typeof receiver.foo; + } + ic(); + ic(); + return obj; + eval(obj); +} + +var rident = /^[a-z$_][a-z$_0-9]*$/i; +function isIdentifier(str) { + return rident.test(str); +} + +function filledRange(count, prefix, suffix) { + var ret = new Array(count); + for(var i = 0; i < count; ++i) { + ret[i] = prefix + i + suffix; + } + return ret; +} + +function safeToString(obj) { + try { + return obj + ""; + } catch (e) { + return "[no string representation]"; + } +} + +function isError(obj) { + return obj instanceof Error || + (obj !== null && + typeof obj === "object" && + typeof obj.message === "string" && + typeof obj.name === "string"); +} + +function markAsOriginatingFromRejection(e) { + try { + notEnumerableProp(e, "isOperational", true); + } + catch(ignore) {} +} + +function originatesFromRejection(e) { + if (e == null) return false; + return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) || + e["isOperational"] === true); +} + +function canAttachTrace(obj) { + return isError(obj) && es5.propertyIsWritable(obj, "stack"); +} + +var ensureErrorObject = (function() { + if (!("stack" in new Error())) { + return function(value) { + if (canAttachTrace(value)) return value; + try {throw new Error(safeToString(value));} + catch(err) {return err;} + }; + } else { + return function(value) { + if (canAttachTrace(value)) return value; + return new Error(safeToString(value)); + }; + } +})(); + +function classString(obj) { + return {}.toString.call(obj); +} + +function copyDescriptors(from, to, filter) { + var keys = es5.names(from); + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + if (filter(key)) { + try { + es5.defineProperty(to, key, es5.getDescriptor(from, key)); + } catch (ignore) {} + } + } +} + +var asArray = function(v) { + if (es5.isArray(v)) { + return v; + } + return null; +}; + +if (typeof Symbol !== "undefined" && Symbol.iterator) { + var ArrayFrom = typeof Array.from === "function" ? function(v) { + return Array.from(v); + } : function(v) { + var ret = []; + var it = v[Symbol.iterator](); + var itResult; + while (!((itResult = it.next()).done)) { + ret.push(itResult.value); + } + return ret; + }; + + asArray = function(v) { + if (es5.isArray(v)) { + return v; + } else if (v != null && typeof v[Symbol.iterator] === "function") { + return ArrayFrom(v); + } + return null; + }; +} + +var isNode = typeof process !== "undefined" && + classString(process).toLowerCase() === "[object process]"; + +var hasEnvVariables = typeof process !== "undefined" && + typeof process.env !== "undefined"; + +function env(key) { + return hasEnvVariables ? process.env[key] : undefined; +} + +function getNativePromise() { + if (typeof Promise === "function") { + try { + var promise = new Promise(function(){}); + if ({}.toString.call(promise) === "[object Promise]") { + return Promise; + } + } catch (e) {} + } +} + +function domainBind(self, cb) { + return self.bind(cb); +} + +var ret = { + isClass: isClass, + isIdentifier: isIdentifier, + inheritedDataKeys: inheritedDataKeys, + getDataPropertyOrDefault: getDataPropertyOrDefault, + thrower: thrower, + isArray: es5.isArray, + asArray: asArray, + notEnumerableProp: notEnumerableProp, + isPrimitive: isPrimitive, + isObject: isObject, + isError: isError, + canEvaluate: canEvaluate, + errorObj: errorObj, + tryCatch: tryCatch, + inherits: inherits, + withAppended: withAppended, + maybeWrapAsError: maybeWrapAsError, + toFastProperties: toFastProperties, + filledRange: filledRange, + toString: safeToString, + canAttachTrace: canAttachTrace, + ensureErrorObject: ensureErrorObject, + originatesFromRejection: originatesFromRejection, + markAsOriginatingFromRejection: markAsOriginatingFromRejection, + classString: classString, + copyDescriptors: copyDescriptors, + hasDevTools: typeof chrome !== "undefined" && chrome && + typeof chrome.loadTimes === "function", + isNode: isNode, + hasEnvVariables: hasEnvVariables, + env: env, + global: globalObject, + getNativePromise: getNativePromise, + domainBind: domainBind +}; +ret.isRecentNode = ret.isNode && (function() { + var version = process.versions.node.split(".").map(Number); + return (version[0] === 0 && version[1] > 10) || (version[0] > 0); +})(); + +if (ret.isNode) ret.toFastProperties(process); + +try {throw new Error(); } catch (e) {ret.lastLineError = e;} +module.exports = ret; + +},{"./es5":13}]},{},[4])(4) +}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; } +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate) +},{"_process":117,"timers":142}],4:[function(require,module,exports){ + +},{}],5:[function(require,module,exports){ /*! * The buffer module from node.js, for the browser. * @@ -2075,7 +7725,7 @@ function numberIsNaN (obj) { return obj !== obj // eslint-disable-line no-self-compare } -},{"base64-js":1,"ieee754":55}],5:[function(require,module,exports){ +},{"base64-js":1,"ieee754":60}],6:[function(require,module,exports){ (function (process){ var tty = require('tty'); var encode = require('./lib/encode'); @@ -2384,7 +8034,7 @@ var extractCodes = exports.extractCodes = function (buf) { } }).call(this,require('_process')) -},{"./lib/encode":6,"_process":98,"stream":112,"tty":129}],6:[function(require,module,exports){ +},{"./lib/encode":7,"_process":117,"stream":139,"tty":143}],7:[function(require,module,exports){ (function (Buffer){ var encode = module.exports = function (xs) { function bytes (s) { @@ -2406,7 +8056,7 @@ var ord = encode.ord = function ord (c) { }; }).call(this,require("buffer").Buffer) -},{"buffer":4}],7:[function(require,module,exports){ +},{"buffer":5}],8:[function(require,module,exports){ (function (Buffer){ /**! * contentstream - index.js @@ -2455,7 +8105,1751 @@ ContentStream.prototype._read = function (n) { }; }).call(this,require("buffer").Buffer) -},{"buffer":4,"readable-stream":106,"util":135}],8:[function(require,module,exports){ +},{"buffer":5,"readable-stream":14,"util":150}],9:[function(require,module,exports){ +(function (process){ +// 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. + +// a duplex stream is just a stream that is both readable and writable. +// Since JS doesn't have multiple prototypal inheritance, this class +// prototypally inherits from Readable, and then parasitically from +// Writable. + +module.exports = Duplex; + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +} +/**/ + + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var Readable = require('./_stream_readable'); +var Writable = require('./_stream_writable'); + +util.inherits(Duplex, Readable); + +forEach(objectKeys(Writable.prototype), function(method) { + if (!Duplex.prototype[method]) + Duplex.prototype[method] = Writable.prototype[method]; +}); + +function Duplex(options) { + if (!(this instanceof Duplex)) + return new Duplex(options); + + Readable.call(this, options); + Writable.call(this, options); + + if (options && options.readable === false) + this.readable = false; + + if (options && options.writable === false) + this.writable = false; + + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) + this.allowHalfOpen = false; + + this.once('end', onend); +} + +// the no-half-open enforcer +function onend() { + // if we allow half-open state, or if the writable side ended, + // then we're ok. + if (this.allowHalfOpen || this._writableState.ended) + return; + + // no more data can be written. + // But allow more writes to happen in this tick. + process.nextTick(this.end.bind(this)); +} + +function forEach (xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +}).call(this,require('_process')) +},{"./_stream_readable":11,"./_stream_writable":13,"_process":117,"core-util-is":15,"inherits":70}],10:[function(require,module,exports){ +// 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. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + +module.exports = PassThrough; + +var Transform = require('./_stream_transform'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(PassThrough, Transform); + +function PassThrough(options) { + if (!(this instanceof PassThrough)) + return new PassThrough(options); + + Transform.call(this, options); +} + +PassThrough.prototype._transform = function(chunk, encoding, cb) { + cb(null, chunk); +}; + +},{"./_stream_transform":12,"core-util-is":15,"inherits":70}],11:[function(require,module,exports){ +(function (process){ +// 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. + +module.exports = Readable; + +/**/ +var isArray = require('isarray'); +/**/ + + +/**/ +var Buffer = require('buffer').Buffer; +/**/ + +Readable.ReadableState = ReadableState; + +var EE = require('events').EventEmitter; + +/**/ +if (!EE.listenerCount) EE.listenerCount = function(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +var Stream = require('stream'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var StringDecoder; + +util.inherits(Readable, Stream); + +function ReadableState(options, stream) { + options = options || {}; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + var hwm = options.highWaterMark; + this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024; + + // cast to ints. + this.highWaterMark = ~~this.highWaterMark; + + this.buffer = []; + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = false; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // In streams that never have any data, and do push(null) right away, + // the consumer can miss the 'end' event if they do some I/O before + // consuming the stream. So, we don't emit('end') until some reading + // happens. + this.calledRead = false; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, becuase any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // when piping, we only care about 'readable' events that happen + // after read()ing all the bytes and not getting any pushback. + this.ranOut = false; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) + StringDecoder = require('string_decoder/').StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + if (!(this instanceof Readable)) + return new Readable(options); + + this._readableState = new ReadableState(options, this); + + // legacy + this.readable = true; + + Stream.call(this); +} + +// Manually shove something into the read() buffer. +// This returns true if the highWaterMark has not been hit yet, +// similar to how Writable.write() returns true if you should +// write() some more. +Readable.prototype.push = function(chunk, encoding) { + var state = this._readableState; + + if (typeof chunk === 'string' && !state.objectMode) { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = new Buffer(chunk, encoding); + encoding = ''; + } + } + + return readableAddChunk(this, state, chunk, encoding, false); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function(chunk) { + var state = this._readableState; + return readableAddChunk(this, state, chunk, '', true); +}; + +function readableAddChunk(stream, state, chunk, encoding, addToFront) { + var er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (chunk === null || chunk === undefined) { + state.reading = false; + if (!state.ended) + onEofChunk(stream, state); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (state.ended && !addToFront) { + var e = new Error('stream.push() after EOF'); + stream.emit('error', e); + } else if (state.endEmitted && addToFront) { + var e = new Error('stream.unshift() after end event'); + stream.emit('error', e); + } else { + if (state.decoder && !addToFront && !encoding) + chunk = state.decoder.write(chunk); + + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) { + state.buffer.unshift(chunk); + } else { + state.reading = false; + state.buffer.push(chunk); + } + + if (state.needReadable) + emitReadable(stream); + + maybeReadMore(stream, state); + } + } else if (!addToFront) { + state.reading = false; + } + + return needMoreData(state); +} + + + +// if it's past the high water mark, we can push in some more. +// Also, if we have no data yet, we can stand some +// more bytes. This is to work around cases where hwm=0, +// such as the repl. Also, if the push() triggered a +// readable event, and the user called read(largeNumber) such that +// needReadable was set, then we ought to push more, so that another +// 'readable' event will be triggered. +function needMoreData(state) { + return !state.ended && + (state.needReadable || + state.length < state.highWaterMark || + state.length === 0); +} + +// backwards compatibility. +Readable.prototype.setEncoding = function(enc) { + if (!StringDecoder) + StringDecoder = require('string_decoder/').StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; +}; + +// Don't raise the hwm > 128MB +var MAX_HWM = 0x800000; +function roundUpToNextPowerOf2(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + // Get the next highest power of 2 + n--; + for (var p = 1; p < 32; p <<= 1) n |= n >> p; + n++; + } + return n; +} + +function howMuchToRead(n, state) { + if (state.length === 0 && state.ended) + return 0; + + if (state.objectMode) + return n === 0 ? 0 : 1; + + if (n === null || isNaN(n)) { + // only flow one buffer at a time + if (state.flowing && state.buffer.length) + return state.buffer[0].length; + else + return state.length; + } + + if (n <= 0) + return 0; + + // If we're asking for more than the target buffer level, + // then raise the water mark. Bump up to the next highest + // power of 2, to prevent increasing it excessively in tiny + // amounts. + if (n > state.highWaterMark) + state.highWaterMark = roundUpToNextPowerOf2(n); + + // don't have that much. return null, unless we've ended. + if (n > state.length) { + if (!state.ended) { + state.needReadable = true; + return 0; + } else + return state.length; + } + + return n; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function(n) { + var state = this._readableState; + state.calledRead = true; + var nOrig = n; + var ret; + + if (typeof n !== 'number' || n > 0) + state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && + state.needReadable && + (state.length >= state.highWaterMark || state.ended)) { + emitReadable(this); + return null; + } + + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + ret = null; + + // In cases where the decoder did not receive enough data + // to produce a full chunk, then immediately received an + // EOF, state.buffer will contain [, ]. + // howMuchToRead will see this and coerce the amount to + // read to zero (because it's looking at the length of the + // first in state.buffer), and we'll end up here. + // + // This can only happen via state.decoder -- no other venue + // exists for pushing a zero-length chunk into state.buffer + // and triggering this behavior. In this case, we return our + // remaining data and end the stream, if appropriate. + if (state.length > 0 && state.decoder) { + ret = fromList(n, state); + state.length -= ret.length; + } + + if (state.length === 0) + endReadable(this); + + return ret; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + + // if we currently have less than the highWaterMark, then also read some + if (state.length - n <= state.highWaterMark) + doRead = true; + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) + doRead = false; + + if (doRead) { + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) + state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + } + + // If _read called its callback synchronously, then `reading` + // will be false, and we need to re-evaluate how much data we + // can return to the user. + if (doRead && !state.reading) + n = howMuchToRead(nOrig, state); + + if (n > 0) + ret = fromList(n, state); + else + ret = null; + + if (ret === null) { + state.needReadable = true; + n = 0; + } + + state.length -= n; + + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (state.length === 0 && !state.ended) + state.needReadable = true; + + // If we happened to read() exactly the remaining amount in the + // buffer, and the EOF has been seen at this point, then make sure + // that we emit 'end' on the very next tick. + if (state.ended && !state.endEmitted && state.length === 0) + endReadable(this); + + return ret; +}; + +function chunkInvalid(state, chunk) { + var er = null; + if (!Buffer.isBuffer(chunk) && + 'string' !== typeof chunk && + chunk !== null && + chunk !== undefined && + !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; +} + + +function onEofChunk(stream, state) { + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + + // if we've ended and we have some data left, then emit + // 'readable' now to make sure it gets picked up. + if (state.length > 0) + emitReadable(stream); + else + endReadable(stream); +} + +// Don't emit readable right away in sync mode, because this can trigger +// another read() call => stack overflow. This way, it might trigger +// a nextTick recursion warning, but that's not so bad. +function emitReadable(stream) { + var state = stream._readableState; + state.needReadable = false; + if (state.emittedReadable) + return; + + state.emittedReadable = true; + if (state.sync) + process.nextTick(function() { + emitReadable_(stream); + }); + else + emitReadable_(stream); +} + +function emitReadable_(stream) { + stream.emit('readable'); +} + + +// at this point, the user has presumably seen the 'readable' event, +// and called read() to consume some data. that may have triggered +// in turn another _read(n) call, in which case reading = true if +// it's in progress. +// However, if we're not ended, or reading, and the length < hwm, +// then go ahead and try to read some more preemptively. +function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + process.nextTick(function() { + maybeReadMore_(stream, state); + }); + } +} + +function maybeReadMore_(stream, state) { + var len = state.length; + while (!state.reading && !state.flowing && !state.ended && + state.length < state.highWaterMark) { + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break; + else + len = state.length; + } + state.readingMore = false; +} + +// abstract method. to be overridden in specific implementation classes. +// call cb(er, data) where data is <= n in length. +// for virtual (non-string, non-buffer) streams, "length" is somewhat +// arbitrary, and perhaps not very meaningful. +Readable.prototype._read = function(n) { + this.emit('error', new Error('not implemented')); +}; + +Readable.prototype.pipe = function(dest, pipeOpts) { + var src = this; + var state = this._readableState; + + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + + var doEnd = (!pipeOpts || pipeOpts.end !== false) && + dest !== process.stdout && + dest !== process.stderr; + + var endFn = doEnd ? onend : cleanup; + if (state.endEmitted) + process.nextTick(endFn); + else + src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable) { + if (readable !== src) return; + cleanup(); + } + + function onend() { + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + + function cleanup() { + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', cleanup); + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (!dest._writableState || dest._writableState.needDrain) + ondrain(); + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + unpipe(); + dest.removeListener('error', onerror); + if (EE.listenerCount(dest, 'error') === 0) + dest.emit('error', er); + } + // This is a brutally ugly hack to make sure that our error handler + // is attached before any userland ones. NEVER DO THIS. + if (!dest._events || !dest._events.error) + dest.on('error', onerror); + else if (isArray(dest._events.error)) + dest._events.error.unshift(onerror); + else + dest._events.error = [onerror, dest._events.error]; + + + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + + function unpipe() { + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + // the handler that waits for readable events after all + // the data gets sucked out in flow. + // This would be easier to follow with a .once() handler + // in flow(), but that is too slow. + this.on('readable', pipeOnReadable); + + state.flowing = true; + process.nextTick(function() { + flow(src); + }); + } + + return dest; +}; + +function pipeOnDrain(src) { + return function() { + var dest = this; + var state = src._readableState; + state.awaitDrain--; + if (state.awaitDrain === 0) + flow(src); + }; +} + +function flow(src) { + var state = src._readableState; + var chunk; + state.awaitDrain = 0; + + function write(dest, i, list) { + var written = dest.write(chunk); + if (false === written) { + state.awaitDrain++; + } + } + + while (state.pipesCount && null !== (chunk = src.read())) { + + if (state.pipesCount === 1) + write(state.pipes, 0, null); + else + forEach(state.pipes, write); + + src.emit('data', chunk); + + // if anyone needs a drain, then we have to wait for that. + if (state.awaitDrain > 0) + return; + } + + // if every destination was unpiped, either before entering this + // function, or in the while loop, then stop flowing. + // + // NB: This is a pretty rare edge case. + if (state.pipesCount === 0) { + state.flowing = false; + + // if there were data event listeners added, then switch to old mode. + if (EE.listenerCount(src, 'data') > 0) + emitDataEvents(src); + return; + } + + // at this point, no one needed a drain, so we just ran out of data + // on the next readable event, start it over again. + state.ranOut = true; +} + +function pipeOnReadable() { + if (this._readableState.ranOut) { + this._readableState.ranOut = false; + flow(this); + } +} + + +Readable.prototype.unpipe = function(dest) { + var state = this._readableState; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) + return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) + return this; + + if (!dest) + dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + this.removeListener('readable', pipeOnReadable); + state.flowing = false; + if (dest) + dest.emit('unpipe', this); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + this.removeListener('readable', pipeOnReadable); + state.flowing = false; + + for (var i = 0; i < len; i++) + dests[i].emit('unpipe', this); + return this; + } + + // try to find the right one. + var i = indexOf(state.pipes, dest); + if (i === -1) + return this; + + state.pipes.splice(i, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) + state.pipes = state.pipes[0]; + + dest.emit('unpipe', this); + + return this; +}; + +// set up data events if they are asked for +// Ensure readable listeners eventually get something +Readable.prototype.on = function(ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + + if (ev === 'data' && !this._readableState.flowing) + emitDataEvents(this); + + if (ev === 'readable' && this.readable) { + var state = this._readableState; + if (!state.readableListening) { + state.readableListening = true; + state.emittedReadable = false; + state.needReadable = true; + if (!state.reading) { + this.read(0); + } else if (state.length) { + emitReadable(this, state); + } + } + } + + return res; +}; +Readable.prototype.addListener = Readable.prototype.on; + +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. +Readable.prototype.resume = function() { + emitDataEvents(this); + this.read(0); + this.emit('resume'); +}; + +Readable.prototype.pause = function() { + emitDataEvents(this, true); + this.emit('pause'); +}; + +function emitDataEvents(stream, startPaused) { + var state = stream._readableState; + + if (state.flowing) { + // https://github.com/isaacs/readable-stream/issues/16 + throw new Error('Cannot switch to old mode now.'); + } + + var paused = startPaused || false; + var readable = false; + + // convert to an old-style stream. + stream.readable = true; + stream.pipe = Stream.prototype.pipe; + stream.on = stream.addListener = Stream.prototype.on; + + stream.on('readable', function() { + readable = true; + + var c; + while (!paused && (null !== (c = stream.read()))) + stream.emit('data', c); + + if (c === null) { + readable = false; + stream._readableState.needReadable = true; + } + }); + + stream.pause = function() { + paused = true; + this.emit('pause'); + }; + + stream.resume = function() { + paused = false; + if (readable) + process.nextTick(function() { + stream.emit('readable'); + }); + else + this.read(0); + this.emit('resume'); + }; + + // now make it start, just in case it hadn't already. + stream.emit('readable'); +} + +// wrap an old-style stream as the async data source. +// This is *not* part of the readable stream interface. +// It is an ugly unfortunate mess of history. +Readable.prototype.wrap = function(stream) { + var state = this._readableState; + var paused = false; + + var self = this; + stream.on('end', function() { + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) + self.push(chunk); + } + + self.push(null); + }); + + stream.on('data', function(chunk) { + if (state.decoder) + chunk = state.decoder.write(chunk); + + // don't skip over falsy values in objectMode + //if (state.objectMode && util.isNullOrUndefined(chunk)) + if (state.objectMode && (chunk === null || chunk === undefined)) + return; + else if (!state.objectMode && (!chunk || !chunk.length)) + return; + + var ret = self.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (typeof stream[i] === 'function' && + typeof this[i] === 'undefined') { + this[i] = function(method) { return function() { + return stream[method].apply(stream, arguments); + }}(i); + } + } + + // proxy certain important events. + var events = ['error', 'close', 'destroy', 'pause', 'resume']; + forEach(events, function(ev) { + stream.on(ev, self.emit.bind(self, ev)); + }); + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + self._read = function(n) { + if (paused) { + paused = false; + stream.resume(); + } + }; + + return self; +}; + + + +// exposed for testing purposes only. +Readable._fromList = fromList; + +// Pluck off n bytes from an array of buffers. +// Length is the combined lengths of all the buffers in the list. +function fromList(n, state) { + var list = state.buffer; + var length = state.length; + var stringMode = !!state.decoder; + var objectMode = !!state.objectMode; + var ret; + + // nothing in the list, definitely empty. + if (list.length === 0) + return null; + + if (length === 0) + ret = null; + else if (objectMode) + ret = list.shift(); + else if (!n || n >= length) { + // read it all, truncate the array. + if (stringMode) + ret = list.join(''); + else + ret = Buffer.concat(list, length); + list.length = 0; + } else { + // read just some of it. + if (n < list[0].length) { + // just take a part of the first list item. + // slice is the same for buffers and strings. + var buf = list[0]; + ret = buf.slice(0, n); + list[0] = buf.slice(n); + } else if (n === list[0].length) { + // first list is a perfect match + ret = list.shift(); + } else { + // complex case. + // we have enough to cover it, but it spans past the first buffer. + if (stringMode) + ret = ''; + else + ret = new Buffer(n); + + var c = 0; + for (var i = 0, l = list.length; i < l && c < n; i++) { + var buf = list[0]; + var cpy = Math.min(n - c, buf.length); + + if (stringMode) + ret += buf.slice(0, cpy); + else + buf.copy(ret, c, 0, cpy); + + if (cpy < buf.length) + list[0] = buf.slice(cpy); + else + list.shift(); + + c += cpy; + } + } + } + + return ret; +} + +function endReadable(stream) { + var state = stream._readableState; + + // If we get here before consuming all the bytes, then that is a + // bug in node. Should never happen. + if (state.length > 0) + throw new Error('endReadable called on non-empty stream'); + + if (!state.endEmitted && state.calledRead) { + state.ended = true; + process.nextTick(function() { + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + } + }); + } +} + +function forEach (xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +function indexOf (xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} + +}).call(this,require('_process')) +},{"_process":117,"buffer":5,"core-util-is":15,"events":48,"inherits":70,"isarray":73,"stream":139,"string_decoder/":140}],12:[function(require,module,exports){ +// 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. + + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + +module.exports = Transform; + +var Duplex = require('./_stream_duplex'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(Transform, Duplex); + + +function TransformState(options, stream) { + this.afterTransform = function(er, data) { + return afterTransform(stream, er, data); + }; + + this.needTransform = false; + this.transforming = false; + this.writecb = null; + this.writechunk = null; +} + +function afterTransform(stream, er, data) { + var ts = stream._transformState; + ts.transforming = false; + + var cb = ts.writecb; + + if (!cb) + return stream.emit('error', new Error('no writecb in Transform class')); + + ts.writechunk = null; + ts.writecb = null; + + if (data !== null && data !== undefined) + stream.push(data); + + if (cb) + cb(er); + + var rs = stream._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + stream._read(rs.highWaterMark); + } +} + + +function Transform(options) { + if (!(this instanceof Transform)) + return new Transform(options); + + Duplex.call(this, options); + + var ts = this._transformState = new TransformState(options, this); + + // when the writable side finishes, then flush out anything remaining. + var stream = this; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + + this.once('finish', function() { + if ('function' === typeof this._flush) + this._flush(function(er) { + done(stream, er); + }); + else + done(stream); + }); +} + +Transform.prototype.push = function(chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function(chunk, encoding, cb) { + throw new Error('not implemented'); +}; + +Transform.prototype._write = function(chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || + rs.needReadable || + rs.length < rs.highWaterMark) + this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function(n) { + var ts = this._transformState; + + if (ts.writechunk !== null && ts.writecb && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; + + +function done(stream, er) { + if (er) + return stream.emit('error', er); + + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + var ws = stream._writableState; + var rs = stream._readableState; + var ts = stream._transformState; + + if (ws.length) + throw new Error('calling transform done when ws.length != 0'); + + if (ts.transforming) + throw new Error('calling transform done when still transforming'); + + return stream.push(null); +} + +},{"./_stream_duplex":9,"core-util-is":15,"inherits":70}],13:[function(require,module,exports){ +(function (process){ +// 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. + +// A bit simpler than readable streams. +// Implement an async ._write(chunk, cb), and it'll handle all +// the drain event emission and buffering. + +module.exports = Writable; + +/**/ +var Buffer = require('buffer').Buffer; +/**/ + +Writable.WritableState = WritableState; + + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var Stream = require('stream'); + +util.inherits(Writable, Stream); + +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; +} + +function WritableState(options, stream) { + options = options || {}; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + var hwm = options.highWaterMark; + this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + // cast to ints. + this.highWaterMark = ~~this.highWaterMark; + + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, becuase any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function(er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + + this.buffer = []; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; +} + +function Writable(options) { + var Duplex = require('./_stream_duplex'); + + // Writable ctor is applied to Duplexes, though they're not + // instanceof Writable, they're instanceof Readable. + if (!(this instanceof Writable) && !(this instanceof Duplex)) + return new Writable(options); + + this._writableState = new WritableState(options, this); + + // legacy. + this.writable = true; + + Stream.call(this); +} + +// Otherwise people can pipe Writable streams, which is just wrong. +Writable.prototype.pipe = function() { + this.emit('error', new Error('Cannot pipe. Not readable.')); +}; + + +function writeAfterEnd(stream, state, cb) { + var er = new Error('write after end'); + // TODO: defer error events consistently everywhere, not just the cb + stream.emit('error', er); + process.nextTick(function() { + cb(er); + }); +} + +// If we get something that is not a buffer, string, null, or undefined, +// and we're not in objectMode, then that's an error. +// Otherwise stream chunks are all considered to be of length=1, and the +// watermarks determine how many objects to keep in the buffer, rather than +// how many bytes or characters. +function validChunk(stream, state, chunk, cb) { + var valid = true; + if (!Buffer.isBuffer(chunk) && + 'string' !== typeof chunk && + chunk !== null && + chunk !== undefined && + !state.objectMode) { + var er = new TypeError('Invalid non-string/buffer chunk'); + stream.emit('error', er); + process.nextTick(function() { + cb(er); + }); + valid = false; + } + return valid; +} + +Writable.prototype.write = function(chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (Buffer.isBuffer(chunk)) + encoding = 'buffer'; + else if (!encoding) + encoding = state.defaultEncoding; + + if (typeof cb !== 'function') + cb = function() {}; + + if (state.ended) + writeAfterEnd(this, state, cb); + else if (validChunk(this, state, chunk, cb)) + ret = writeOrBuffer(this, state, chunk, encoding, cb); + + return ret; +}; + +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && + state.decodeStrings !== false && + typeof chunk === 'string') { + chunk = new Buffer(chunk, encoding); + } + return chunk; +} + +// if we're already writing something, then just put this +// in the queue, and wait our turn. Otherwise, call _write +// If we return false, then we need a drain event, so set that flag. +function writeOrBuffer(stream, state, chunk, encoding, cb) { + chunk = decodeChunk(state, chunk, encoding); + if (Buffer.isBuffer(chunk)) + encoding = 'buffer'; + var len = state.objectMode ? 1 : chunk.length; + + state.length += len; + + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) + state.needDrain = true; + + if (state.writing) + state.buffer.push(new WriteReq(chunk, encoding, cb)); + else + doWrite(stream, state, len, chunk, encoding, cb); + + return ret; +} + +function doWrite(stream, state, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + stream._write(chunk, encoding, state.onwrite); + state.sync = false; +} + +function onwriteError(stream, state, sync, er, cb) { + if (sync) + process.nextTick(function() { + cb(er); + }); + else + cb(er); + + stream._writableState.errorEmitted = true; + stream.emit('error', er); +} + +function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; +} + +function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + + onwriteStateUpdate(state); + + if (er) + onwriteError(stream, state, sync, er, cb); + else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(stream, state); + + if (!finished && !state.bufferProcessing && state.buffer.length) + clearBuffer(stream, state); + + if (sync) { + process.nextTick(function() { + afterWrite(stream, state, finished, cb); + }); + } else { + afterWrite(stream, state, finished, cb); + } + } +} + +function afterWrite(stream, state, finished, cb) { + if (!finished) + onwriteDrain(stream, state); + cb(); + if (finished) + finishMaybe(stream, state); +} + +// Must force callback to be called on nextTick, so that we don't +// emit 'drain' before the write() consumer gets the 'false' return +// value, and has a chance to attach a 'drain' listener. +function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } +} + + +// if there's something in the buffer waiting, then process it +function clearBuffer(stream, state) { + state.bufferProcessing = true; + + for (var c = 0; c < state.buffer.length; c++) { + var entry = state.buffer[c]; + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + + doWrite(stream, state, len, chunk, encoding, cb); + + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + c++; + break; + } + } + + state.bufferProcessing = false; + if (c < state.buffer.length) + state.buffer = state.buffer.slice(c); + else + state.buffer.length = 0; +} + +Writable.prototype._write = function(chunk, encoding, cb) { + cb(new Error('not implemented')); +}; + +Writable.prototype.end = function(chunk, encoding, cb) { + var state = this._writableState; + + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (typeof chunk !== 'undefined' && chunk !== null) + this.write(chunk, encoding); + + // ignore unnecessary end() calls. + if (!state.ending && !state.finished) + endWritable(this, state, cb); +}; + + +function needFinish(stream, state) { + return (state.ending && + state.length === 0 && + !state.finished && + !state.writing); +} + +function finishMaybe(stream, state) { + var need = needFinish(stream, state); + if (need) { + state.finished = true; + stream.emit('finish'); + } + return need; +} + +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) + process.nextTick(cb); + else + stream.once('finish', cb); + } + state.ended = true; +} + +}).call(this,require('_process')) +},{"./_stream_duplex":9,"_process":117,"buffer":5,"core-util-is":15,"inherits":70,"stream":139}],14:[function(require,module,exports){ +(function (process){ +var Stream = require('stream'); // hack to fix a circular dependency issue when used with browserify +exports = module.exports = require('./lib/_stream_readable.js'); +exports.Stream = Stream; +exports.Readable = exports; +exports.Writable = require('./lib/_stream_writable.js'); +exports.Duplex = require('./lib/_stream_duplex.js'); +exports.Transform = require('./lib/_stream_transform.js'); +exports.PassThrough = require('./lib/_stream_passthrough.js'); +if (!process.browser && process.env.READABLE_STREAM === 'disable') { + module.exports = require('stream'); +} + +}).call(this,require('_process')) +},{"./lib/_stream_duplex.js":9,"./lib/_stream_passthrough.js":10,"./lib/_stream_readable.js":11,"./lib/_stream_transform.js":12,"./lib/_stream_writable.js":13,"_process":117,"stream":139}],15:[function(require,module,exports){ (function (Buffer){ // Copyright Joyent, Inc. and other Node contributors. // @@ -2566,7 +9960,7 @@ function objectToString(o) { } }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) -},{"../../is-buffer/index.js":59}],9:[function(require,module,exports){ +},{"../../is-buffer/index.js":72}],16:[function(require,module,exports){ "use strict" var createThunk = require("./lib/thunk.js") @@ -2677,7 +10071,7 @@ function compileCwise(user_args) { module.exports = compileCwise -},{"./lib/thunk.js":11}],10:[function(require,module,exports){ +},{"./lib/thunk.js":18}],17:[function(require,module,exports){ "use strict" var uniq = require("uniq") @@ -3037,7 +10431,7 @@ function generateCWiseOp(proc, typesig) { } module.exports = generateCWiseOp -},{"uniq":131}],11:[function(require,module,exports){ +},{"uniq":146}],18:[function(require,module,exports){ "use strict" // The function below is called when constructing a cwise function object, and does the following: @@ -3125,9 +10519,9 @@ function createThunk(proc) { module.exports = createThunk -},{"./compile.js":10}],12:[function(require,module,exports){ +},{"./compile.js":17}],19:[function(require,module,exports){ module.exports = require("cwise-compiler") -},{"cwise-compiler":9}],13:[function(require,module,exports){ +},{"cwise-compiler":16}],20:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -3197,7 +10591,7 @@ function dataUriToBuffer (uri) { } }).call(this,require("buffer").Buffer) -},{"buffer":4}],14:[function(require,module,exports){ +},{"buffer":5}],21:[function(require,module,exports){ "use strict" function dupe_array(count, value, i) { @@ -3247,7 +10641,7 @@ function dupe(count, value) { } module.exports = dupe -},{}],15:[function(require,module,exports){ +},{}],22:[function(require,module,exports){ var FisheyeGl = function FisheyeGl(options){ // Defaults: @@ -3555,7 +10949,7 @@ if (typeof(document) != 'undefined') else module.exports = FisheyeGl; -},{"./shaders":16}],16:[function(require,module,exports){ +},{"./shaders":23}],23:[function(require,module,exports){ module.exports = { fragment: require('./shaders/fragment.glfs'), fragment2: require('./shaders/fragment2.glfs'), @@ -3565,7 +10959,7 @@ module.exports = { vertex: require('./shaders/vertex.glvs') }; -},{"./shaders/fragment.glfs":17,"./shaders/fragment2.glfs":18,"./shaders/fragment3.glfs":19,"./shaders/method1.glfs":20,"./shaders/method2.glfs":21,"./shaders/vertex.glvs":22}],17:[function(require,module,exports){ +},{"./shaders/fragment.glfs":24,"./shaders/fragment2.glfs":25,"./shaders/fragment3.glfs":26,"./shaders/method1.glfs":27,"./shaders/method2.glfs":28,"./shaders/vertex.glvs":29}],24:[function(require,module,exports){ module.exports = "\ #ifdef GL_ES\n\ precision highp float;\n\ @@ -3593,7 +10987,7 @@ void main(void){\n\ gl_FragColor = texture;\n\ }\n\ "; -},{}],18:[function(require,module,exports){ +},{}],25:[function(require,module,exports){ module.exports = "\ #ifdef GL_ES\n\ precision highp float;\n\ @@ -3626,7 +11020,7 @@ void main(void){\n\ gl_FragColor = texture;\n\ }\n\ "; -},{}],19:[function(require,module,exports){ +},{}],26:[function(require,module,exports){ module.exports = "\ #ifdef GL_ES\n\ precision highp float;\n\ @@ -3657,7 +11051,7 @@ void main(void){\n\ gl_FragColor = texture;\n\ }\n\ "; -},{}],20:[function(require,module,exports){ +},{}],27:[function(require,module,exports){ module.exports = "\ #ifdef GL_ES\n\ precision highp float;\n\ @@ -3689,7 +11083,7 @@ void main(void){\n\ gl_FragColor = texture;\n\ }\n\ "; -},{}],21:[function(require,module,exports){ +},{}],28:[function(require,module,exports){ module.exports = "\ #ifdef GL_ES\n\ precision highp float;\n\ @@ -3721,7 +11115,7 @@ void main(void){\n\ gl_FragColor = texture;\n\ }\n\ "; -},{}],22:[function(require,module,exports){ +},{}],29:[function(require,module,exports){ module.exports = "\ #ifdef GL_ES\n\ precision highp float;\n\ @@ -3736,7 +11130,7 @@ void main(void){\n\ gl_Position = vec4(vPosition,1.0);\n\ }\n\ "; -},{}],23:[function(require,module,exports){ +},{}],30:[function(require,module,exports){ (function (Buffer,process){ 'use strict' @@ -3874,7 +11268,7 @@ module.exports = function getPixels(url, type, cb) { } } }).call(this,{"isBuffer":require("../is-buffer/index.js")},require('_process')) -},{"../is-buffer/index.js":59,"_process":98,"data-uri-to-buffer":24,"ndarray":71,"ndarray-pack":69,"omggif":73,"path":75,"through":127}],24:[function(require,module,exports){ +},{"../is-buffer/index.js":72,"_process":117,"data-uri-to-buffer":31,"ndarray":84,"ndarray-pack":82,"omggif":93,"path":95,"through":141}],31:[function(require,module,exports){ (function (Buffer){ /** @@ -3932,7 +11326,7 @@ function dataUriToBuffer (uri) { } }).call(this,require("buffer").Buffer) -},{"buffer":4}],25:[function(require,module,exports){ +},{"buffer":5}],32:[function(require,module,exports){ (function (Buffer){ /* GIFEncoder.js @@ -4405,7 +11799,7 @@ GIFEncoder.ByteCapacitor = ByteCapacitor; module.exports = GIFEncoder; }).call(this,require("buffer").Buffer) -},{"./LZWEncoder.js":26,"./TypedNeuQuant.js":27,"assert":36,"buffer":4,"events":43,"readable-stream":34,"util":135}],26:[function(require,module,exports){ +},{"./LZWEncoder.js":33,"./TypedNeuQuant.js":34,"assert":41,"buffer":5,"events":48,"readable-stream":40,"util":150}],33:[function(require,module,exports){ /* LZWEncoder.js @@ -4619,7 +12013,7 @@ function LZWEncoder(width, height, pixels, colorDepth) { module.exports = LZWEncoder; -},{}],27:[function(require,module,exports){ +},{}],34:[function(require,module,exports){ /* NeuQuant Neural-Net Quantization Algorithm * ------------------------------------------ * @@ -5052,153 +12446,11 @@ function NeuQuant(pixels, samplefac) { module.exports = NeuQuant; -},{}],28:[function(require,module,exports){ -module.exports = Array.isArray || function (arr) { - return Object.prototype.toString.call(arr) == '[object Array]'; -}; - -},{}],29:[function(require,module,exports){ -(function (process){ -// 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. - -// a duplex stream is just a stream that is both readable and writable. -// Since JS doesn't have multiple prototypal inheritance, this class -// prototypally inherits from Readable, and then parasitically from -// Writable. - -module.exports = Duplex; - -/**/ -var objectKeys = Object.keys || function (obj) { - var keys = []; - for (var key in obj) keys.push(key); - return keys; -} -/**/ - - -/**/ -var util = require('core-util-is'); -util.inherits = require('inherits'); -/**/ - -var Readable = require('./_stream_readable'); -var Writable = require('./_stream_writable'); - -util.inherits(Duplex, Readable); - -forEach(objectKeys(Writable.prototype), function(method) { - if (!Duplex.prototype[method]) - Duplex.prototype[method] = Writable.prototype[method]; -}); - -function Duplex(options) { - if (!(this instanceof Duplex)) - return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) - this.readable = false; - - if (options && options.writable === false) - this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) - this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) - return; - - // no more data can be written. - // But allow more writes to happen in this tick. - process.nextTick(this.end.bind(this)); -} - -function forEach (xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -}).call(this,require('_process')) -},{"./_stream_readable":31,"./_stream_writable":33,"_process":98,"core-util-is":8,"inherits":57}],30:[function(require,module,exports){ -// 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. - -// a passthrough stream. -// basically just the most minimal sort of Transform stream. -// Every written chunk gets output as-is. - -module.exports = PassThrough; - -var Transform = require('./_stream_transform'); - -/**/ -var util = require('core-util-is'); -util.inherits = require('inherits'); -/**/ - -util.inherits(PassThrough, Transform); - -function PassThrough(options) { - if (!(this instanceof PassThrough)) - return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function(chunk, encoding, cb) { - cb(null, chunk); -}; - -},{"./_stream_transform":32,"core-util-is":8,"inherits":57}],31:[function(require,module,exports){ +},{}],35:[function(require,module,exports){ +arguments[4][9][0].apply(exports,arguments) +},{"./_stream_readable":37,"./_stream_writable":39,"_process":117,"core-util-is":15,"dup":9,"inherits":70}],36:[function(require,module,exports){ +arguments[4][10][0].apply(exports,arguments) +},{"./_stream_transform":38,"core-util-is":15,"dup":10,"inherits":70}],37:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // @@ -6153,7 +13405,7 @@ function indexOf (xs, x) { } }).call(this,require('_process')) -},{"./_stream_duplex":29,"_process":98,"buffer":4,"core-util-is":8,"events":43,"inherits":57,"isarray":28,"stream":112,"string_decoder/":35,"util":3}],32:[function(require,module,exports){ +},{"./_stream_duplex":35,"_process":117,"buffer":5,"core-util-is":15,"events":48,"inherits":70,"isarray":73,"stream":139,"string_decoder/":140,"util":4}],38:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -6364,7 +13616,7 @@ function done(stream, er) { return stream.push(null); } -},{"./_stream_duplex":29,"core-util-is":8,"inherits":57}],33:[function(require,module,exports){ +},{"./_stream_duplex":35,"core-util-is":15,"inherits":70}],39:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // @@ -6845,7 +14097,7 @@ function endWritable(stream, state, cb) { } }).call(this,require('_process')) -},{"./_stream_duplex":29,"_process":98,"buffer":4,"core-util-is":8,"inherits":57,"stream":112}],34:[function(require,module,exports){ +},{"./_stream_duplex":35,"_process":117,"buffer":5,"core-util-is":15,"inherits":70,"stream":139}],40:[function(require,module,exports){ (function (process){ exports = module.exports = require('./lib/_stream_readable.js'); exports.Stream = require('stream'); @@ -6859,230 +14111,7 @@ if (!process.browser && process.env.READABLE_STREAM === 'disable') { } }).call(this,require('_process')) -},{"./lib/_stream_duplex.js":29,"./lib/_stream_passthrough.js":30,"./lib/_stream_readable.js":31,"./lib/_stream_transform.js":32,"./lib/_stream_writable.js":33,"_process":98,"stream":112}],35:[function(require,module,exports){ -// 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. - -var Buffer = require('buffer').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. -var StringDecoder = exports.StringDecoder = function(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; -} - -},{"buffer":4}],36:[function(require,module,exports){ +},{"./lib/_stream_duplex.js":35,"./lib/_stream_passthrough.js":36,"./lib/_stream_readable.js":37,"./lib/_stream_transform.js":38,"./lib/_stream_writable.js":39,"_process":117,"stream":139}],41:[function(require,module,exports){ (function (global){ 'use strict'; @@ -7576,7 +14605,7 @@ var objectKeys = Object.keys || function (obj) { }; }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"util/":39}],37:[function(require,module,exports){ +},{"util/":44}],42:[function(require,module,exports){ if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { @@ -7601,14 +14630,14 @@ if (typeof Object.create === 'function') { } } -},{}],38:[function(require,module,exports){ +},{}],43:[function(require,module,exports){ module.exports = function isBuffer(arg) { return arg && typeof arg === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function'; } -},{}],39:[function(require,module,exports){ +},{}],44:[function(require,module,exports){ (function (process,global){ // Copyright Joyent, Inc. and other Node contributors. // @@ -8198,7 +15227,7 @@ function hasOwnProperty(obj, prop) { } }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"./support/isBuffer":38,"_process":98,"inherits":37}],40:[function(require,module,exports){ +},{"./support/isBuffer":43,"_process":117,"inherits":42}],45:[function(require,module,exports){ (function (process,Buffer){ 'use strict'; /* eslint camelcase: "off" */ @@ -8610,7 +15639,7 @@ Zlib.prototype._reset = function () { exports.Zlib = Zlib; }).call(this,require('_process'),require("buffer").Buffer) -},{"_process":98,"assert":36,"buffer":4,"pako/lib/zlib/constants":46,"pako/lib/zlib/deflate.js":48,"pako/lib/zlib/inflate.js":50,"pako/lib/zlib/zstream":54}],41:[function(require,module,exports){ +},{"_process":117,"assert":41,"buffer":5,"pako/lib/zlib/constants":51,"pako/lib/zlib/deflate.js":53,"pako/lib/zlib/inflate.js":55,"pako/lib/zlib/zstream":59}],46:[function(require,module,exports){ (function (process){ 'use strict'; @@ -9222,9 +16251,9 @@ util.inherits(DeflateRaw, Zlib); util.inherits(InflateRaw, Zlib); util.inherits(Unzip, Zlib); }).call(this,require('_process')) -},{"./binding":40,"_process":98,"assert":36,"buffer":4,"stream":112,"util":135}],42:[function(require,module,exports){ -arguments[4][3][0].apply(exports,arguments) -},{"dup":3}],43:[function(require,module,exports){ +},{"./binding":45,"_process":117,"assert":41,"buffer":5,"stream":139,"util":150}],47:[function(require,module,exports){ +arguments[4][4][0].apply(exports,arguments) +},{"dup":4}],48:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -9749,7 +16778,7 @@ function functionBindPolyfill(context) { }; } -},{}],44:[function(require,module,exports){ +},{}],49:[function(require,module,exports){ 'use strict'; @@ -9856,7 +16885,7 @@ exports.setTyped = function (on) { exports.setTyped(TYPED_OK); -},{}],45:[function(require,module,exports){ +},{}],50:[function(require,module,exports){ 'use strict'; // Note: adler32 takes 12% for level 0 and 2% for level 6. @@ -9909,7 +16938,7 @@ function adler32(adler, buf, len, pos) { module.exports = adler32; -},{}],46:[function(require,module,exports){ +},{}],51:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -9979,7 +17008,7 @@ module.exports = { //Z_NULL: null // Use -1 or null inline, depending on var type }; -},{}],47:[function(require,module,exports){ +},{}],52:[function(require,module,exports){ 'use strict'; // Note: we can't get significant speed boost here. @@ -10040,7 +17069,7 @@ function crc32(crc, buf, len, pos) { module.exports = crc32; -},{}],48:[function(require,module,exports){ +},{}],53:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -11916,7 +18945,7 @@ exports.deflatePrime = deflatePrime; exports.deflateTune = deflateTune; */ -},{"../utils/common":44,"./adler32":45,"./crc32":47,"./messages":52,"./trees":53}],49:[function(require,module,exports){ +},{"../utils/common":49,"./adler32":50,"./crc32":52,"./messages":57,"./trees":58}],54:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -12263,7 +19292,7 @@ module.exports = function inflate_fast(strm, start) { return; }; -},{}],50:[function(require,module,exports){ +},{}],55:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -13821,7 +20850,7 @@ exports.inflateSyncPoint = inflateSyncPoint; exports.inflateUndermine = inflateUndermine; */ -},{"../utils/common":44,"./adler32":45,"./crc32":47,"./inffast":49,"./inftrees":51}],51:[function(require,module,exports){ +},{"../utils/common":49,"./adler32":50,"./crc32":52,"./inffast":54,"./inftrees":56}],56:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -14166,7 +21195,7 @@ module.exports = function inflate_table(type, lens, lens_index, codes, table, ta return 0; }; -},{"../utils/common":44}],52:[function(require,module,exports){ +},{"../utils/common":49}],57:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -14200,7 +21229,7 @@ module.exports = { '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */ }; -},{}],53:[function(require,module,exports){ +},{}],58:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -15422,7 +22451,7 @@ exports._tr_flush_block = _tr_flush_block; exports._tr_tally = _tr_tally; exports._tr_align = _tr_align; -},{"../utils/common":44}],54:[function(require,module,exports){ +},{"../utils/common":49}],59:[function(require,module,exports){ 'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler @@ -15471,7 +22500,7 @@ function ZStream() { module.exports = ZStream; -},{}],55:[function(require,module,exports){ +},{}],60:[function(require,module,exports){ exports.read = function (buffer, offset, isLE, mLen, nBytes) { var e, m var eLen = (nBytes * 8) - mLen - 1 @@ -15557,7 +22586,7 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { buffer[offset + i - d] |= s * 128 } -},{}],56:[function(require,module,exports){ +},{}],61:[function(require,module,exports){ /* * Invert the image */ @@ -15609,9 +22638,2774 @@ var info = { } } module.exports = [Invert,info]; -},{}],57:[function(require,module,exports){ -arguments[4][37][0].apply(exports,arguments) -},{"dup":37}],58:[function(require,module,exports){ +},{}],62:[function(require,module,exports){ +/** + * Copyright (c) 2015 Guyon Roche + * + * 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. + * + */ +"use strict"; + +var _ = require("underscore"); + +var main = module.exports = { + Bitmap: require("./lib/bitmap") +}; + +_.extend(main, require("./lib/enums")); + +},{"./lib/bitmap":63,"./lib/enums":64,"underscore":145}],63:[function(require,module,exports){ +(function (Buffer){ +/** + * Copyright (c) 2015 Guyon Roche + * + * 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. + * + */ +"use strict"; + +var fs = require("fs"); +var _ = require("underscore"); +var Promise = require("bluebird"); +var jpeg = require("jpeg-js"); +//var png = require("png-js"); +var PNG = require("node-png").PNG; + +var Enums = require("./enums"); +var Utils = require("./utils"); +var Resize = require("./resize"); +//var Graphics = require("./graphics"); + +// default pad colour +var transparentBlack = { + r: 0, g: 0, b: 0, a: 0 +}; + +var Bitmap = module.exports = function(options) { + if (options) { + if (options instanceof Bitmap) { + this._data = { + data: new Buffer(options.data.data), + width: options.width, + height: options.height + }; + } else if (options.data) { + // attach to supplied data + this._data = options; + } else if (options.width && options.height) { + // construct new bitmap + this._data = { + data: new Buffer(4 * options.width * options.height), + width: options.width, + height: options.height + }; + + // optional colour + if (options.color) { + this._fill(options.color); + } + } + } +}; + +Bitmap.prototype = { + get width() { + return this._data.width; + }, + get height() { + return this._data.height; + }, + //get graphics() { + // if (!this._graphics) { + // this._graphics = new Graphics(this); + // } + // return this._graphics; + //}, + + attach: function(data) { + var prev = this._data; + this._data = data; + return prev; + }, + detach: function() { + var data = this._data; + delete this._data; + return data; + }, + + _deduceFileType: function(filename) { + if (!filename) { + throw new Error("Can't determine image type"); + } + switch (filename.substr(-4).toLowerCase()) { + case ".jpg": + return Enums.ImageType.JPG; + case ".png": + return Enums.ImageType.PNG; + } + if (filename.substr(-5).toLowerCase() == ".jpeg") { + return Enums.ImageType.JPG; + } + throw new Error("Can't recognise image type: " + filename); + }, + + _readStream: function(stream) { + var self = this; + var deferred = Promise.defer(); + + var chunks = []; + stream.on('data', function(chunk) { + chunks.push(chunk); + }); + stream.on('end', function() { + var data = Buffer.concat(chunks); + deferred.resolve(data); + }); + stream.on('error', function(error) { + deferred.reject(error); + }); + + return deferred.promise; + }, + _readPNG: function(stream) { + var deferred = Promise.defer(); + + var png = new PNG({filterType: 4}); + png.on('parsed', function() { + deferred.resolve(png); + }); + png.on('error', function(error) { + deferred.rejecyt(error); + }); + stream.pipe(png); + + return deferred.promise; + }, + _parseOptions: function(options, filename) { + options = options || {}; + if (typeof options === "number") { + options = { type: options }; + } + options.type = options.type || this._deduceFileType(filename); + return options; + }, + read: function(stream, options) { + var self = this; + options = this._parseOptions(options); + + switch(options.type) { + case Enums.ImageType.JPG: + return this._readStream(stream) + .then(function(data) { + self._data = jpeg.decode(data); + }); + case Enums.ImageType.PNG: + return this._readPNG(stream) + .then(function(png) { + self._data = { + data: png.data, + width: png.width, + height: png.height + }; + }); + default: + return Promise.reject(new Error("Not supported: ImageType " + options.type)); + } + }, + readFile: function(filename, options) { + var self = this; + return Utils.fs.exists(filename) + .then(function(exists) { + if (exists) { + options = self._parseOptions(options, filename); + var stream = fs.createReadStream(filename); + return self.read(stream, options); + } else { + throw new Error("File Not Found: " + filename); + } + }); + }, + + write: function(stream, options) { + options = this._parseOptions(options); + var deferred = Promise.defer(); + try { + stream.on('finish', function() { + deferred.resolve(); + }); + stream.on('error', function(error) { + deferred.reject(error); + }); + + switch(options.type) { + case Enums.ImageType.JPG: + var buffer = jpeg.encode(this._data, options.quality || 90).data; + stream.write(buffer); + stream.end(); + break; + case Enums.ImageType.PNG: + var png = new PNG(); + png.width = this.width; + png.height = this.height; + png.data = this._data.data; + png.on('end', function() { + deferred.resolve(); + }); + png.on('error', function(error) { + deferred.reject(error); + }); + png.pack().pipe(stream); + break; + default: + throw new Error("Not supported: ImageType " + options.type); + } + } + catch(ex) { + deferred.reject(ex); + } + return deferred.promise; + }, + writeFile: function(filename, options) { + options = this._parseOptions(options, filename); + var stream = fs.createWriteStream(filename); + return this.write(stream, options); + }, + + clone: function() { + return new Bitmap({ + width: this.width, + height: this.height, + data: new Buffer(this._data.data) + }); + }, + + setPixel: function(x,y, r,g,b,a) { + if (g === undefined) { + var color = r; + r = color.r; + g = color.g; + b = color.b; + a = color.a; + } + if (a === undefined) a = 255; + var pos = (y * this.width + x) * 4; + var buffer = this._data.data; + buffer[pos++] = r; + buffer[pos++] = g; + buffer[pos++] = b; + buffer[pos++] = a; + }, + getPixel: function(x,y, color) { + var pos = (y * this.width + x) * 4; + color = color || {}; + var buffer = this._data.data; + color.r = buffer[pos++]; + color.g = buffer[pos++]; + color.b = buffer[pos++]; + color.a = buffer[pos++]; + return color; + }, + + negative: function() { + var that = new Bitmap({width: this.width, height: this.height}); + var n = this.width * this.height; + + var src = this._data.data; + var dst = that._data.data; + var srcPos = 0; + var dstPos = 0; + for (var i = 0; i < n; i++) { + dst[dstPos++] = 255 - src[srcPos++]; + dst[dstPos++] = 255 - src[srcPos++]; + dst[dstPos++] = 255 - src[srcPos++]; + dst[dstPos++] = src[srcPos++]; + } + return that; + }, + + resize: function(options) { + var that = new Bitmap(options); + var temp; + switch (options.fit) { + case "pad": // fit all of src in dst with aspect ratio preserved. + var padColor = options.padColor || transparentBlack; + var srcAr = this.width / this.height; + var w2 = Math.round(srcAr * that.height); + var h2 = Math.round(that.width / srcAr); + var wMargin = 0; + var hMargin = 0; + if (w2 < that.width) { + // pad sides + temp = new Bitmap({width: w2, height: that.height}); + wMargin = (that.width - w2) / 2; + that._fill(padColor, 0, 0, Math.floor(wMargin), that.height); + that._fill(padColor, that.width - Math.ceil(wMargin), 0, Math.ceil(wMargin), that.height); + + Resize[options.algorithm](this, temp, options); + that._blt(temp, {left: Math.floor(wMargin), top: Math.floor(hMargin)}); + } else if (h2 < that.height) { + // pad top & bottom + temp = new Bitmap({width: that.width, height: h2}); + hMargin = (that.height - h2) / 2; + that._fill(padColor, 0, 0, that.width, Math.floor(hMargin)); + that._fill(padColor, 0, that.height - Math.ceil(hMargin), that.width, Math.ceil(hMargin)); + + Resize[options.algorithm](this, temp, options); + that._blt(temp, {left: Math.floor(wMargin), top: Math.floor(hMargin)}); + } else { + // stretch straight into that + Resize[options.algorithm](this, that, options); + } + break; + case "crop": // crop original to fit in dst with aspect ratio preserved + var gravity = options.gravity || {x: 0.5, y: 0.5}; + var dstAr = that.width / that.height; + var w2 = Math.round(dstAr * this.height); + var h2 = Math.round(this.width / dstAr); + if (w2 < this.width) { + // crop src width + var dw = this.width - w2; + temp = this.crop({left: Math.round(gravity.x * dw), top: 0, width: w2, height: this.height}); + } else if (h2 < this.height) { + // crop src height + var dh = this.height - h2; + temp = this.crop({left: 0, top: Math.round(gravity.y * dh), width: this.width, height: h2}); + } else { + temp = this; + } + Resize[options.algorithm](temp, that, options); + break; + case "stretch": + default: + Resize[options.algorithm](this, that, options); + break; + } + + return that; + }, + + rotate: function(options) { + // TODO: crop, user supplied dst width, height + + // options.degrees || options.radians; + // options.fit = ['pad','crop','same'] + // options.padColor + var radians = options.radians !== undefined ? options.radians : 3.141592653589793 * options.degrees / 180; + if (radians < 0.000000001) { + return new Bitmap(this); + } + //console.log("radians=" + radians); + + var rotators = { + forward: { + cos: Math.cos(radians), + sin: Math.sin(radians) + }, + backward: { + cos: Math.cos(-radians), + sin: Math.sin(-radians) + } + } + //console.log("cos=" + cos + ", sin=" + sin) + + var srcWidth = this.width; + var srcHeight = this.height; + var srcWidthHalf = srcWidth / 2; + var srcHeightHalf = srcHeight / 2; + + var padColor = options.padColor || transparentBlack; + var padArray = [padColor.r, padColor.g, padColor.b, padColor.a]; + var rotate = function(point, rotator) { + // in-place rotation of point + var x = rotator.cos * point.x - rotator.sin * point.y; + var y = rotator.sin * point.x + rotator.cos * point.y; + point.x = x; + point.y = y; + return point; + }; + var cropToSource = function(point) { + var m = Math.abs(point.x/srcWidthHalf); + var n = Math.abs(point.y/srcHeightHalf); + return Math.max(m,n); + }; + + var dstWidth, dstHeight; + switch (options.fit) { + case 'custom': + dstWidth = options.width; + dstHeight = options.height; + break; + case 'pad': + // entire src fits in dst + var tl = rotate({x:-srcWidthHalf,y:srcHeightHalf}, rotators.forward); + var tr = rotate({x:srcWidthHalf,y:srcHeightHalf}, rotators.forward); + var bl = rotate({x:-srcWidthHalf,y:-srcHeightHalf}, rotators.forward); + var br = rotate({x:srcWidthHalf,y:-srcHeightHalf}, rotators.forward); + dstWidth = Math.round(Math.max(tl.x,tr.x,bl.x,br.x) - Math.min(tl.x,tr.x,bl.x,br.x)); + dstHeight = Math.round(Math.max(tl.y,tr.y,bl.y,br.y) - Math.min(tl.y,tr.y,bl.y,br.y)); + break; + case 'crop': + var tl = rotate({x:-srcWidthHalf,y:srcHeightHalf}, rotators.forward); + var tr = rotate({x:srcWidthHalf,y:srcHeightHalf}, rotators.forward); + var bl = rotate({x:-srcWidthHalf,y:-srcHeightHalf}, rotators.forward); + var br = rotate({x:srcWidthHalf,y:-srcHeightHalf}, rotators.forward); + var d = Math.max(cropToSource(tl), cropToSource(tr), cropToSource(bl), cropToSource(br)); + dstWidth = Math.floor(srcWidth / d); + dstHeight = Math.floor(srcHeight / d); + break; + case 'same': + default: + // dst is same size as src + dstWidth = srcWidth; + dstHeight = srcHeight; + break; + } + + var that = new Bitmap({width: dstWidth, height: dstHeight}); + + var srcBuf = this._data.data; + var dstBuf = that._data.data; + + // we will rotate the destination pixels back to the source and interpolate the colour + var srcCoord = {}; + var dstWidthHalf = dstWidth / 2; + var dstHeightHalf = dstHeight / 2; + var dstWidth4 = dstWidth * 4; + var srcWidth4 = srcWidth * 4; + + //console.log("src=[" + srcWidth + "," + srcHeight + "]") + //console.log("dst=[" + dstWidth + "," + dstHeight + "]") + for (var i = 0; i < dstHeight; i++) { + for (var j = 0; j < dstWidth; j++) { + // calculate src coords + srcCoord.x = j - dstWidthHalf; + srcCoord.y = dstHeightHalf - i; + //console.log("x=" + srcCoord.x + ", y=" + srcCoord.y); + rotate(srcCoord, rotators.backward); + //console.log(" ==> x=" + srcCoord.x + ", y=" + srcCoord.y); + + // srcX and SrcY are in src coords + var srcX = srcCoord.x + srcWidthHalf; + var srcY = srcHeightHalf - srcCoord.y; + //console.log("srcX=" + srcX + ", srcY=" + srcY); + + // now interpolate (bilinear! + var dstPos = (i * dstWidth + j) * 4; + //console.log("dstPos=" + dstPos) + if ((srcX > -1) && (srcX < srcWidth) && (srcY > -1) && (srcY < srcHeight)) { + var srcPosX = Math.floor(srcX); + var srcPosY = Math.floor(srcY); + var srcPos = (srcPosY * srcWidth + srcPosX) * 4; + for (var k = 0; k < 4; k++) { + var kSrcPos = srcPos + k; + var kPad = padArray[k]; + + var tl = ((srcX >= 0) && (srcY >= 0)) ? srcBuf[kSrcPos] : kPad; + var tr = ((srcX < srcWidth-1) && (srcY >= 0)) ? srcBuf[kSrcPos+4] : kPad; + var bl = ((srcX >= 0) && (srcY < srcHeight-1)) ? srcBuf[kSrcPos + srcWidth4] : kPad; + var br = ((srcX < srcWidth-1) && (srcY < srcHeight-1)) ? srcBuf[kSrcPos + srcWidth4 + 4] : kPad; + + var tx = srcX - srcPosX; + var ty = srcY - srcPosY; + + var t = (1-tx) * tl + tx * tr; + var b = (1-tx) * bl + tx * br; + dstBuf[dstPos++] = (1-ty) * t + ty * b; + } + } else { + dstBuf[dstPos++] = padColor.r; + dstBuf[dstPos++] = padColor.g; + dstBuf[dstPos++] = padColor.b; + dstBuf[dstPos++] = padColor.a; + } + } + } + return that; + }, + + crop: function(options) { + var t = options.top; + var l = options.left; + var w = options.width; + var h = options.height; + //console.log("Crop: l="+l + ", t="+t + ", w="+w + ", h="+h); + + var that = new Bitmap({width: w, height: h}); + + var srcBuf = this._data.data; + var dstBuf = that._data.data; + + var w4 = w * 4; + for (var i = 0; i < h; i++) { + var srcPos = ((i+t)*this.width + l) * 4; + var dstPos = i * w * 4; + srcBuf.copy(dstBuf, dstPos, srcPos, srcPos + w4); + } + return that; + }, + + blur: function(options) { + // todo: expand to own file with different blur algorithms + var that = new Bitmap({width: this.width, height: this.height}); + var w = this.width; + var h = this.height; + + var W = w-1; + var H = h-1; + + var V = w*4; // used for i offsets + + var src = this._data.data; + var dst = that._data.data; + for (var i = 0; i < h; i++) { + for (var j = 0; j < w; j++) { + for (var k = 0; k < 4; k++) { + var pos = (i*w + j) * 4 + k; + var t = src[pos -(i>0?V:0) - (j>0?4:0)] * 1 + // 1/16 + src[pos -(i>0?V:0) ] * 2 + // 2/16 + src[pos -(i>0?V:0) + (j0?4:0)] * 2 + // 2/16 + src[pos ] * 4 + // 4/16 + src[pos + (j0?4:0)] * 1 + // 1/16 + src[pos +(i + * + * 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. + * + */ +"use strict"; + +module.exports = { + ImageType: { + JPG: 1, + PNG: 2 + } +}; +},{}],65:[function(require,module,exports){ +(function (Buffer){ +/** + * Copyright (c) 2015 Guyon Roche + * + * 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. + * + */ +"use strict"; + +var _ = require("underscore"); +var Promise = require("bluebird"); + +module.exports = { + _writeFile: function(width, height, data, filename) { + // for debugging + + var Bitmap = require("./bitmap"); + var bmp = new Bitmap({ + width: width, height: height, + data: data + }); + bmp.writeFile(filename); + }, + + nearestNeighbor: function(src, dst, options) { + + var wSrc = src.width; + var hSrc = src.height; + //console.log("wSrc="+wSrc + ", hSrc="+hSrc); + + var wDst = dst.width; + var hDst = dst.height; + //console.log("wDst="+wDst + ", hDst="+hDst); + + var bufSrc = src._data.data; + var bufDst = dst._data.data; + + for (var i = 0; i < hDst; i++) { + for (var j = 0; j < wDst; j++) { + var posDst = (i * wDst + j) * 4; + + var iSrc = Math.round(i * hSrc / hDst); + var jSrc = Math.round(j * wSrc / wDst); + var posSrc = (iSrc * wSrc + jSrc) * 4; + + bufDst[posDst++] = bufSrc[posSrc++]; + bufDst[posDst++] = bufSrc[posSrc++]; + bufDst[posDst++] = bufSrc[posSrc++]; + bufDst[posDst++] = bufSrc[posSrc++]; + } + } + }, + bilinearInterpolation: function(src, dst, options) { + + var wSrc = src.width; + var hSrc = src.height; + //console.log("wSrc="+wSrc + ", hSrc="+hSrc); + + var wDst = dst.width; + var hDst = dst.height; + //console.log("wDst="+wDst + ", hDst="+hDst); + + var bufSrc = src._data.data; + var bufDst = dst._data.data; + + var interpolate = function(k, kMin, vMin, kMax, vMax) { + // special case - k is integer + if (kMin === kMax) { + return vMin; + } + + return Math.round((k - kMin) * vMax + (kMax - k) * vMin); + }; + var assign = function(pos, offset, x, xMin, xMax, y, yMin, yMax) { + var posMin = (yMin * wSrc + xMin) * 4 + offset; + var posMax = (yMin * wSrc + xMax) * 4 + offset; + var vMin = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]); + + // special case, y is integer + if (yMax === yMin) { + bufDst[pos+offset] = vMin; + } else { + posMin = (yMax * wSrc + xMin) * 4 + offset; + posMax = (yMax * wSrc + xMax) * 4 + offset; + var vMax = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]); + + bufDst[pos+offset] = interpolate(y, yMin, vMin, yMax, vMax); + } + } + + for (var i = 0; i < hDst; i++) { + for (var j = 0; j < wDst; j++) { + var posDst = (i * wDst + j) * 4; + + // x & y in src coordinates + var x = j * wSrc / wDst; + var xMin = Math.floor(x); + var xMax = Math.min(Math.ceil(x), wSrc-1); + + var y = i * hSrc / hDst; + var yMin = Math.floor(y); + var yMax = Math.min(Math.ceil(y), hSrc-1); + + assign(posDst, 0, x, xMin, xMax, y, yMin, yMax); + assign(posDst, 1, x, xMin, xMax, y, yMin, yMax); + assign(posDst, 2, x, xMin, xMax, y, yMin, yMax); + assign(posDst, 3, x, xMin, xMax, y, yMin, yMax); + } + } + }, + + _interpolate2D: function(src, dst, options, interpolate) { + + var bufSrc = src._data.data; + var bufDst = dst._data.data; + + var wSrc = src.width; + var hSrc = src.height; + //console.log("wSrc="+wSrc + ", hSrc="+hSrc + ", srcLen="+bufSrc.length); + + var wDst = dst.width; + var hDst = dst.height; + //console.log("wDst="+wDst + ", hDst="+hDst + ", dstLen="+bufDst.length); + + // when dst smaller than src/2, interpolate first to a multiple between 0.5 and 1.0 src, then sum squares + var wM = Math.max(1, Math.floor(wSrc / wDst)); + var wDst2 = wDst * wM; + var hM = Math.max(1, Math.floor(hSrc / hDst)); + var hDst2 = hDst * hM; + //console.log("wM="+wM + ", wDst2="+wDst2 + ", hM="+hM + ", hDst2="+hDst2); + + // =========================================================== + // Pass 1 - interpolate rows + // buf1 has width of dst2 and height of src + var buf1 = new Buffer(wDst2 * hSrc * 4); + for (var i = 0; i < hSrc; i++) { + for (var j = 0; j < wDst2; j++) { + // i in src coords, j in dst coords + + // calculate x in src coords + // this interpolation requires 4 sample points and the two inner ones must be real + // the outer points can be fudged for the edges. + // therefore (wSrc-1)/wDst2 + var x = j * (wSrc-1) / wDst2; + var xPos = Math.floor(x); + var t = x - xPos; + var srcPos = (i * wSrc + xPos) * 4; + + var buf1Pos = (i * wDst2 + j) * 4; + for (var k = 0; k < 4; k++) { + var kPos = srcPos + k; + var x0 = (xPos > 0) ? bufSrc[kPos - 4] : 2*bufSrc[kPos]-bufSrc[kPos+4]; + var x1 = bufSrc[kPos]; + var x2 = bufSrc[kPos + 4]; + var x3 = (xPos < wSrc - 2) ? bufSrc[kPos + 8] : 2*bufSrc[kPos + 4]-bufSrc[kPos]; + buf1[buf1Pos+k] = interpolate(x0,x1,x2,x3,t); + } + } + } + //this._writeFile(wDst2, hSrc, buf1, "out/buf1.jpg"); + + // =========================================================== + // Pass 2 - interpolate columns + // buf2 has width and height of dst2 + var buf2 = new Buffer(wDst2 * hDst2 * 4); + for (var i = 0; i < hDst2; i++) { + for (var j = 0; j < wDst2; j++) { + // i&j in dst2 coords + + // calculate y in buf1 coords + // this interpolation requires 4 sample points and the two inner ones must be real + // the outer points can be fudged for the edges. + // therefore (hSrc-1)/hDst2 + var y = i * (hSrc-1) / hDst2; + var yPos = Math.floor(y); + var t = y - yPos; + var buf1Pos = (yPos * wDst2 + j) * 4; + var buf2Pos = (i * wDst2 + j) * 4; + for (var k = 0; k < 4; k++) { + var kPos = buf1Pos + k; + var y0 = (yPos > 0) ? buf1[kPos - wDst2*4] : 2*buf1[kPos]-buf1[kPos + wDst2*4]; + var y1 = buf1[kPos]; + var y2 = buf1[kPos + wDst2*4]; + var y3 = (yPos < hSrc-2) ? buf1[kPos + wDst2*8] : 2*buf1[kPos + wDst2*4]-buf1[kPos]; + + buf2[buf2Pos + k] = interpolate(y0,y1,y2,y3,t); + } + } + } + //this._writeFile(wDst2, hDst2, buf2, "out/buf2.jpg"); + + // =========================================================== + // Pass 3 - scale to dst + var m = wM * hM; + if (m > 1) { + for (var i = 0; i < hDst; i++) { + for (var j = 0; j < wDst; j++) { + // i&j in dst bounded coords + var r = 0; + var g = 0; + var b = 0; + var a = 0; + for (var y = 0; y < hM; y++) { + var yPos = i * hM + y; + for (var x = 0; x < wM; x++) { + var xPos = j * wM + x; + var xyPos = (yPos * wDst2 + xPos) * 4; + r += buf2[xyPos]; + g += buf2[xyPos+1]; + b += buf2[xyPos+2]; + a += buf2[xyPos+3]; + } + } + + var pos = (i*wDst + j) * 4; + bufDst[pos] = Math.round(r / m); + bufDst[pos+1] = Math.round(g / m); + bufDst[pos+2] = Math.round(b / m); + bufDst[pos+3] = Math.round(a / m); + } + } + } else { + // replace dst buffer with buf2 + dst._data.data = buf2; + } + }, + + bicubicInterpolation: function(src, dst, options) { + var interpolateCubic = function(x0, x1, x2, x3, t) { + var a0 = x3 - x2 - x0 + x1; + var a1 = x0 - x1 - a0; + var a2 = x2 - x0; + var a3 = x1; + return Math.max(0,Math.min(255,(a0 * (t * t * t)) + (a1 * (t * t)) + (a2 * t) + (a3))); + } + return this._interpolate2D(src, dst, options, interpolateCubic); + }, + + hermiteInterpolation: function(src, dst, options) { + var interpolateHermite = function(x0, x1, x2, x3, t) + { + var c0 = x1; + var c1 = 0.5 * (x2 - x0); + var c2 = x0 - (2.5 * x1) + (2 * x2) - (0.5 * x3); + var c3 = (0.5 * (x3 - x0)) + (1.5 * (x1 - x2)); + return Math.max(0,Math.min(255,Math.round((((((c3 * t) + c2) * t) + c1) * t) + c0))); + } + return this._interpolate2D(src, dst, options, interpolateHermite); + }, + + bezierInterpolation: function(src, dst, options) { + // between 2 points y(n), y(n+1), use next points out, y(n-1), y(n+2) + // to predict control points (a & b) to be placed at n+0.5 + // ya(n) = y(n) + (y(n+1)-y(n-1))/4 + // yb(n) = y(n+1) - (y(n+2)-y(n))/4 + // then use std bezier to interpolate [n,n+1) + // y(n+t) = y(n)*(1-t)^3 + 3 * ya(n)*(1-t)^2*t + 3 * yb(n)*(1-t)*t^2 + y(n+1)*t^3 + // note the 3* factor for the two control points + // for edge cases, can choose: + // y(-1) = y(0) - 2*(y(1)-y(0)) + // y(w) = y(w-1) + 2*(y(w-1)-y(w-2)) + // but can go with y(-1) = y(0) and y(w) = y(w-1) + var interpolateBezier = function(x0, x1, x2, x3, t) { + // x1, x2 are the knots, use x0 and x3 to calculate control points + var cp1 = x1 + (x2-x0)/4; + var cp2 = x2 - (x3-x1)/4; + var nt = 1-t; + var c0 = x1 * nt * nt * nt; + var c1 = 3 * cp1 * nt * nt * t; + var c2 = 3 * cp2 * nt * t * t; + var c3 = x2 * t * t * t; + return Math.max(0,Math.min(255,Math.round(c0 + c1 + c2 + c3))); + } + return this._interpolate2D(src, dst, options, interpolateBezier); + } +} +}).call(this,require("buffer").Buffer) +},{"./bitmap":63,"bluebird":3,"buffer":5,"underscore":145}],66:[function(require,module,exports){ +/** + * Copyright (c) 2015 Guyon Roche + * + * 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. + * + */ +"use strict"; + +var fs = require("fs"); +var _ = require("underscore"); +var Promise = require("bluebird"); + + +var utils = module.exports = { + + // Promisification of fs + fs: { + exists: function(filename) { + var deferred = Promise.defer(); + fs.exists(filename, function(exists) { + deferred.resolve(exists); + }); + return deferred.promise; + } + } +} +},{"bluebird":3,"fs":47,"underscore":145}],67:[function(require,module,exports){ +var encode = require('./lib/encoder'), + decode = require('./lib/decoder'); + +module.exports = { + encode: encode, + decode: decode +}; + +},{"./lib/decoder":68,"./lib/encoder":69}],68:[function(require,module,exports){ +(function (Buffer){ +/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- / +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* + Copyright 2011 notmasteryet + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +// - The JPEG specification can be found in the ITU CCITT Recommendation T.81 +// (www.w3.org/Graphics/JPEG/itu-t81.pdf) +// - The JFIF specification can be found in the JPEG File Interchange Format +// (www.w3.org/Graphics/JPEG/jfif3.pdf) +// - The Adobe Application-Specific JPEG markers in the Supporting the DCT Filters +// in PostScript Level 2, Technical Note #5116 +// (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf) + +var JpegImage = (function jpegImage() { + "use strict"; + var dctZigZag = new Int32Array([ + 0, + 1, 8, + 16, 9, 2, + 3, 10, 17, 24, + 32, 25, 18, 11, 4, + 5, 12, 19, 26, 33, 40, + 48, 41, 34, 27, 20, 13, 6, + 7, 14, 21, 28, 35, 42, 49, 56, + 57, 50, 43, 36, 29, 22, 15, + 23, 30, 37, 44, 51, 58, + 59, 52, 45, 38, 31, + 39, 46, 53, 60, + 61, 54, 47, + 55, 62, + 63 + ]); + + var dctCos1 = 4017 // cos(pi/16) + var dctSin1 = 799 // sin(pi/16) + var dctCos3 = 3406 // cos(3*pi/16) + var dctSin3 = 2276 // sin(3*pi/16) + var dctCos6 = 1567 // cos(6*pi/16) + var dctSin6 = 3784 // sin(6*pi/16) + var dctSqrt2 = 5793 // sqrt(2) + var dctSqrt1d2 = 2896 // sqrt(2) / 2 + + function constructor() { + } + + function buildHuffmanTable(codeLengths, values) { + var k = 0, code = [], i, j, length = 16; + while (length > 0 && !codeLengths[length - 1]) + length--; + code.push({children: [], index: 0}); + var p = code[0], q; + for (i = 0; i < length; i++) { + for (j = 0; j < codeLengths[i]; j++) { + p = code.pop(); + p.children[p.index] = values[k]; + while (p.index > 0) { + p = code.pop(); + } + p.index++; + code.push(p); + while (code.length <= i) { + code.push(q = {children: [], index: 0}); + p.children[p.index] = q.children; + p = q; + } + k++; + } + if (i + 1 < length) { + // p here points to last code + code.push(q = {children: [], index: 0}); + p.children[p.index] = q.children; + p = q; + } + } + return code[0].children; + } + + function decodeScan(data, offset, + frame, components, resetInterval, + spectralStart, spectralEnd, + successivePrev, successive) { + var precision = frame.precision; + var samplesPerLine = frame.samplesPerLine; + var scanLines = frame.scanLines; + var mcusPerLine = frame.mcusPerLine; + var progressive = frame.progressive; + var maxH = frame.maxH, maxV = frame.maxV; + + var startOffset = offset, bitsData = 0, bitsCount = 0; + function readBit() { + if (bitsCount > 0) { + bitsCount--; + return (bitsData >> bitsCount) & 1; + } + bitsData = data[offset++]; + if (bitsData == 0xFF) { + var nextByte = data[offset++]; + if (nextByte) { + throw "unexpected marker: " + ((bitsData << 8) | nextByte).toString(16); + } + // unstuff 0 + } + bitsCount = 7; + return bitsData >>> 7; + } + function decodeHuffman(tree) { + var node = tree, bit; + while ((bit = readBit()) !== null) { + node = node[bit]; + if (typeof node === 'number') + return node; + if (typeof node !== 'object') + throw "invalid huffman sequence"; + } + return null; + } + function receive(length) { + var n = 0; + while (length > 0) { + var bit = readBit(); + if (bit === null) return; + n = (n << 1) | bit; + length--; + } + return n; + } + function receiveAndExtend(length) { + var n = receive(length); + if (n >= 1 << (length - 1)) + return n; + return n + (-1 << length) + 1; + } + function decodeBaseline(component, zz) { + var t = decodeHuffman(component.huffmanTableDC); + var diff = t === 0 ? 0 : receiveAndExtend(t); + zz[0]= (component.pred += diff); + var k = 1; + while (k < 64) { + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) + break; + k += 16; + continue; + } + k += r; + var z = dctZigZag[k]; + zz[z] = receiveAndExtend(s); + k++; + } + } + function decodeDCFirst(component, zz) { + var t = decodeHuffman(component.huffmanTableDC); + var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive); + zz[0] = (component.pred += diff); + } + function decodeDCSuccessive(component, zz) { + zz[0] |= readBit() << successive; + } + var eobrun = 0; + function decodeACFirst(component, zz) { + if (eobrun > 0) { + eobrun--; + return; + } + var k = spectralStart, e = spectralEnd; + while (k <= e) { + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) { + eobrun = receive(r) + (1 << r) - 1; + break; + } + k += 16; + continue; + } + k += r; + var z = dctZigZag[k]; + zz[z] = receiveAndExtend(s) * (1 << successive); + k++; + } + } + var successiveACState = 0, successiveACNextValue; + function decodeACSuccessive(component, zz) { + var k = spectralStart, e = spectralEnd, r = 0; + while (k <= e) { + var z = dctZigZag[k]; + switch (successiveACState) { + case 0: // initial state + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) { + eobrun = receive(r) + (1 << r); + successiveACState = 4; + } else { + r = 16; + successiveACState = 1; + } + } else { + if (s !== 1) + throw "invalid ACn encoding"; + successiveACNextValue = receiveAndExtend(s); + successiveACState = r ? 2 : 3; + } + continue; + case 1: // skipping r zero items + case 2: + if (zz[z]) + zz[z] += (readBit() << successive); + else { + r--; + if (r === 0) + successiveACState = successiveACState == 2 ? 3 : 0; + } + break; + case 3: // set value for a zero item + if (zz[z]) + zz[z] += (readBit() << successive); + else { + zz[z] = successiveACNextValue << successive; + successiveACState = 0; + } + break; + case 4: // eob + if (zz[z]) + zz[z] += (readBit() << successive); + break; + } + k++; + } + if (successiveACState === 4) { + eobrun--; + if (eobrun === 0) + successiveACState = 0; + } + } + function decodeMcu(component, decode, mcu, row, col) { + var mcuRow = (mcu / mcusPerLine) | 0; + var mcuCol = mcu % mcusPerLine; + var blockRow = mcuRow * component.v + row; + var blockCol = mcuCol * component.h + col; + decode(component, component.blocks[blockRow][blockCol]); + } + function decodeBlock(component, decode, mcu) { + var blockRow = (mcu / component.blocksPerLine) | 0; + var blockCol = mcu % component.blocksPerLine; + decode(component, component.blocks[blockRow][blockCol]); + } + + var componentsLength = components.length; + var component, i, j, k, n; + var decodeFn; + if (progressive) { + if (spectralStart === 0) + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + else + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } else { + decodeFn = decodeBaseline; + } + + var mcu = 0, marker; + var mcuExpected; + if (componentsLength == 1) { + mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn; + } else { + mcuExpected = mcusPerLine * frame.mcusPerColumn; + } + if (!resetInterval) resetInterval = mcuExpected; + + var h, v; + while (mcu < mcuExpected) { + // reset interval stuff + for (i = 0; i < componentsLength; i++) + components[i].pred = 0; + eobrun = 0; + + if (componentsLength == 1) { + component = components[0]; + for (n = 0; n < resetInterval; n++) { + decodeBlock(component, decodeFn, mcu); + mcu++; + } + } else { + for (n = 0; n < resetInterval; n++) { + for (i = 0; i < componentsLength; i++) { + component = components[i]; + h = component.h; + v = component.v; + for (j = 0; j < v; j++) { + for (k = 0; k < h; k++) { + decodeMcu(component, decodeFn, mcu, j, k); + } + } + } + mcu++; + + // If we've reached our expected MCU's, stop decoding + if (mcu === mcuExpected) break; + } + } + + // find marker + bitsCount = 0; + marker = (data[offset] << 8) | data[offset + 1]; + if (marker < 0xFF00) { + throw "marker was not found"; + } + + if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx + offset += 2; + } + else + break; + } + + return offset - startOffset; + } + + function buildComponentData(frame, component) { + var lines = []; + var blocksPerLine = component.blocksPerLine; + var blocksPerColumn = component.blocksPerColumn; + var samplesPerLine = blocksPerLine << 3; + var R = new Int32Array(64), r = new Uint8Array(64); + + // A port of poppler's IDCT method which in turn is taken from: + // Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz, + // "Practical Fast 1-D DCT Algorithms with 11 Multiplications", + // IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989, + // 988-991. + function quantizeAndInverse(zz, dataOut, dataIn) { + var qt = component.quantizationTable; + var v0, v1, v2, v3, v4, v5, v6, v7, t; + var p = dataIn; + var i; + + // dequant + for (i = 0; i < 64; i++) + p[i] = zz[i] * qt[i]; + + // inverse DCT on rows + for (i = 0; i < 8; ++i) { + var row = 8 * i; + + // check for all-zero AC coefficients + if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && + p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && + p[7 + row] == 0) { + t = (dctSqrt2 * p[0 + row] + 512) >> 10; + p[0 + row] = t; + p[1 + row] = t; + p[2 + row] = t; + p[3 + row] = t; + p[4 + row] = t; + p[5 + row] = t; + p[6 + row] = t; + p[7 + row] = t; + continue; + } + + // stage 4 + v0 = (dctSqrt2 * p[0 + row] + 128) >> 8; + v1 = (dctSqrt2 * p[4 + row] + 128) >> 8; + v2 = p[2 + row]; + v3 = p[6 + row]; + v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8; + v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8; + v5 = p[3 + row] << 4; + v6 = p[5 + row] << 4; + + // stage 3 + t = (v0 - v1+ 1) >> 1; + v0 = (v0 + v1 + 1) >> 1; + v1 = t; + t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8; + v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8; + v3 = t; + t = (v4 - v6 + 1) >> 1; + v4 = (v4 + v6 + 1) >> 1; + v6 = t; + t = (v7 + v5 + 1) >> 1; + v5 = (v7 - v5 + 1) >> 1; + v7 = t; + + // stage 2 + t = (v0 - v3 + 1) >> 1; + v0 = (v0 + v3 + 1) >> 1; + v3 = t; + t = (v1 - v2 + 1) >> 1; + v1 = (v1 + v2 + 1) >> 1; + v2 = t; + t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; + v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; + v7 = t; + t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; + v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; + v6 = t; + + // stage 1 + p[0 + row] = v0 + v7; + p[7 + row] = v0 - v7; + p[1 + row] = v1 + v6; + p[6 + row] = v1 - v6; + p[2 + row] = v2 + v5; + p[5 + row] = v2 - v5; + p[3 + row] = v3 + v4; + p[4 + row] = v3 - v4; + } + + // inverse DCT on columns + for (i = 0; i < 8; ++i) { + var col = i; + + // check for all-zero AC coefficients + if (p[1*8 + col] == 0 && p[2*8 + col] == 0 && p[3*8 + col] == 0 && + p[4*8 + col] == 0 && p[5*8 + col] == 0 && p[6*8 + col] == 0 && + p[7*8 + col] == 0) { + t = (dctSqrt2 * dataIn[i+0] + 8192) >> 14; + p[0*8 + col] = t; + p[1*8 + col] = t; + p[2*8 + col] = t; + p[3*8 + col] = t; + p[4*8 + col] = t; + p[5*8 + col] = t; + p[6*8 + col] = t; + p[7*8 + col] = t; + continue; + } + + // stage 4 + v0 = (dctSqrt2 * p[0*8 + col] + 2048) >> 12; + v1 = (dctSqrt2 * p[4*8 + col] + 2048) >> 12; + v2 = p[2*8 + col]; + v3 = p[6*8 + col]; + v4 = (dctSqrt1d2 * (p[1*8 + col] - p[7*8 + col]) + 2048) >> 12; + v7 = (dctSqrt1d2 * (p[1*8 + col] + p[7*8 + col]) + 2048) >> 12; + v5 = p[3*8 + col]; + v6 = p[5*8 + col]; + + // stage 3 + t = (v0 - v1 + 1) >> 1; + v0 = (v0 + v1 + 1) >> 1; + v1 = t; + t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12; + v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12; + v3 = t; + t = (v4 - v6 + 1) >> 1; + v4 = (v4 + v6 + 1) >> 1; + v6 = t; + t = (v7 + v5 + 1) >> 1; + v5 = (v7 - v5 + 1) >> 1; + v7 = t; + + // stage 2 + t = (v0 - v3 + 1) >> 1; + v0 = (v0 + v3 + 1) >> 1; + v3 = t; + t = (v1 - v2 + 1) >> 1; + v1 = (v1 + v2 + 1) >> 1; + v2 = t; + t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; + v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; + v7 = t; + t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; + v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; + v6 = t; + + // stage 1 + p[0*8 + col] = v0 + v7; + p[7*8 + col] = v0 - v7; + p[1*8 + col] = v1 + v6; + p[6*8 + col] = v1 - v6; + p[2*8 + col] = v2 + v5; + p[5*8 + col] = v2 - v5; + p[3*8 + col] = v3 + v4; + p[4*8 + col] = v3 - v4; + } + + // convert to 8-bit integers + for (i = 0; i < 64; ++i) { + var sample = 128 + ((p[i] + 8) >> 4); + dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample; + } + } + + var i, j; + for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) { + var scanLine = blockRow << 3; + for (i = 0; i < 8; i++) + lines.push(new Uint8Array(samplesPerLine)); + for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) { + quantizeAndInverse(component.blocks[blockRow][blockCol], r, R); + + var offset = 0, sample = blockCol << 3; + for (j = 0; j < 8; j++) { + var line = lines[scanLine + j]; + for (i = 0; i < 8; i++) + line[sample + i] = r[offset++]; + } + } + } + return lines; + } + + function clampTo8bit(a) { + return a < 0 ? 0 : a > 255 ? 255 : a; + } + + constructor.prototype = { + load: function load(path) { + var xhr = new XMLHttpRequest(); + xhr.open("GET", path, true); + xhr.responseType = "arraybuffer"; + xhr.onload = (function() { + // TODO catch parse error + var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer); + this.parse(data); + if (this.onload) + this.onload(); + }).bind(this); + xhr.send(null); + }, + parse: function parse(data) { + var offset = 0, length = data.length; + function readUint16() { + var value = (data[offset] << 8) | data[offset + 1]; + offset += 2; + return value; + } + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + function prepareComponents(frame) { + var maxH = 0, maxV = 0; + var component, componentId; + for (componentId in frame.components) { + if (frame.components.hasOwnProperty(componentId)) { + component = frame.components[componentId]; + if (maxH < component.h) maxH = component.h; + if (maxV < component.v) maxV = component.v; + } + } + var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH); + var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV); + for (componentId in frame.components) { + if (frame.components.hasOwnProperty(componentId)) { + component = frame.components[componentId]; + var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH); + var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + var blocks = []; + for (var i = 0; i < blocksPerColumnForMcu; i++) { + var row = []; + for (var j = 0; j < blocksPerLineForMcu; j++) + row.push(new Int32Array(64)); + blocks.push(row); + } + component.blocksPerLine = blocksPerLine; + component.blocksPerColumn = blocksPerColumn; + component.blocks = blocks; + } + } + frame.maxH = maxH; + frame.maxV = maxV; + frame.mcusPerLine = mcusPerLine; + frame.mcusPerColumn = mcusPerColumn; + } + var jfif = null; + var adobe = null; + var pixels = null; + var frame, resetInterval; + var quantizationTables = [], frames = []; + var huffmanTablesAC = [], huffmanTablesDC = []; + var fileMarker = readUint16(); + if (fileMarker != 0xFFD8) { // SOI (Start of Image) + throw "SOI not found"; + } + + fileMarker = readUint16(); + while (fileMarker != 0xFFD9) { // EOI (End of image) + var i, j, l; + switch(fileMarker) { + case 0xFF00: break; + case 0xFFE0: // APP0 (Application Specific) + case 0xFFE1: // APP1 + case 0xFFE2: // APP2 + case 0xFFE3: // APP3 + case 0xFFE4: // APP4 + case 0xFFE5: // APP5 + case 0xFFE6: // APP6 + case 0xFFE7: // APP7 + case 0xFFE8: // APP8 + case 0xFFE9: // APP9 + case 0xFFEA: // APP10 + case 0xFFEB: // APP11 + case 0xFFEC: // APP12 + case 0xFFED: // APP13 + case 0xFFEE: // APP14 + case 0xFFEF: // APP15 + case 0xFFFE: // COM (Comment) + var appData = readDataBlock(); + + if (fileMarker === 0xFFE0) { + if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 && + appData[3] === 0x46 && appData[4] === 0) { // 'JFIF\x00' + jfif = { + version: { major: appData[5], minor: appData[6] }, + densityUnits: appData[7], + xDensity: (appData[8] << 8) | appData[9], + yDensity: (appData[10] << 8) | appData[11], + thumbWidth: appData[12], + thumbHeight: appData[13], + thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13]) + }; + } + } + // TODO APP1 - Exif + if (fileMarker === 0xFFEE) { + if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F && + appData[3] === 0x62 && appData[4] === 0x65 && appData[5] === 0) { // 'Adobe\x00' + adobe = { + version: appData[6], + flags0: (appData[7] << 8) | appData[8], + flags1: (appData[9] << 8) | appData[10], + transformCode: appData[11] + }; + } + } + break; + + case 0xFFDB: // DQT (Define Quantization Tables) + var quantizationTablesLength = readUint16(); + var quantizationTablesEnd = quantizationTablesLength + offset - 2; + while (offset < quantizationTablesEnd) { + var quantizationTableSpec = data[offset++]; + var tableData = new Int32Array(64); + if ((quantizationTableSpec >> 4) === 0) { // 8 bit values + for (j = 0; j < 64; j++) { + var z = dctZigZag[j]; + tableData[z] = data[offset++]; + } + } else if ((quantizationTableSpec >> 4) === 1) { //16 bit + for (j = 0; j < 64; j++) { + var z = dctZigZag[j]; + tableData[z] = readUint16(); + } + } else + throw "DQT: invalid table spec"; + quantizationTables[quantizationTableSpec & 15] = tableData; + } + break; + + case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT) + case 0xFFC1: // SOF1 (Start of Frame, Extended DCT) + case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT) + readUint16(); // skip data length + frame = {}; + frame.extended = (fileMarker === 0xFFC1); + frame.progressive = (fileMarker === 0xFFC2); + frame.precision = data[offset++]; + frame.scanLines = readUint16(); + frame.samplesPerLine = readUint16(); + frame.components = {}; + frame.componentsOrder = []; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + var qId = data[offset + 2]; + frame.componentsOrder.push(componentId); + frame.components[componentId] = { + h: h, + v: v, + quantizationIdx: qId + }; + offset += 3; + } + prepareComponents(frame); + frames.push(frame); + break; + + case 0xFFC4: // DHT (Define Huffman Tables) + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength;) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) + codeLengthSum += (codeLengths[j] = data[offset]); + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) + huffmanValues[j] = data[offset]; + i += 17 + codeLengthSum; + + ((huffmanTableSpec >> 4) === 0 ? + huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = + buildHuffmanTable(codeLengths, huffmanValues); + } + break; + + case 0xFFDD: // DRI (Define Restart Interval) + readUint16(); // skip data length + resetInterval = readUint16(); + break; + + case 0xFFDA: // SOS (Start of Scan) + var scanLength = readUint16(); + var selectorsCount = data[offset++]; + var components = [], component; + for (i = 0; i < selectorsCount; i++) { + component = frame.components[data[offset++]]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, + frame, components, resetInterval, + spectralStart, spectralEnd, + successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + break; + default: + if (data[offset - 3] == 0xFF && + data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) { + // could be incorrect encoding -- last 0xFF byte of the previous + // block was eaten by the encoder + offset -= 3; + break; + } + throw "unknown JPEG marker " + fileMarker.toString(16); + } + fileMarker = readUint16(); + } + if (frames.length != 1) + throw "only single frame JPEGs supported"; + + // set each frame's components quantization table + for (var i = 0; i < frames.length; i++) { + var cp = frames[i].components; + for (var j in cp) { + cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx]; + delete cp[j].quantizationIdx; + } + } + + this.width = frame.samplesPerLine; + this.height = frame.scanLines; + this.jfif = jfif; + this.adobe = adobe; + this.components = []; + for (var i = 0; i < frame.componentsOrder.length; i++) { + var component = frame.components[frame.componentsOrder[i]]; + this.components.push({ + lines: buildComponentData(frame, component), + scaleX: component.h / frame.maxH, + scaleY: component.v / frame.maxV + }); + } + }, + getData: function getData(width, height) { + var scaleX = this.width / width, scaleY = this.height / height; + + var component1, component2, component3, component4; + var component1Line, component2Line, component3Line, component4Line; + var x, y; + var offset = 0; + var Y, Cb, Cr, K, C, M, Ye, R, G, B; + var colorTransform; + var dataLength = width * height * this.components.length; + var data = new Uint8Array(dataLength); + switch (this.components.length) { + case 1: + component1 = this.components[0]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + + data[offset++] = Y; + } + } + break; + case 2: + // PDF might compress two component data in custom colorspace + component1 = this.components[0]; + component2 = this.components[1]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + data[offset++] = Y; + Y = component2Line[0 | (x * component2.scaleX * scaleX)]; + data[offset++] = Y; + } + } + break; + case 3: + // The default transform for three components is true + colorTransform = true; + // The adobe transform marker overrides any previous setting + if (this.adobe && this.adobe.transformCode) + colorTransform = true; + else if (typeof this.colorTransform !== 'undefined') + colorTransform = !!this.colorTransform; + + component1 = this.components[0]; + component2 = this.components[1]; + component3 = this.components[2]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; + component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + if (!colorTransform) { + R = component1Line[0 | (x * component1.scaleX * scaleX)]; + G = component2Line[0 | (x * component2.scaleX * scaleX)]; + B = component3Line[0 | (x * component3.scaleX * scaleX)]; + } else { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + Cb = component2Line[0 | (x * component2.scaleX * scaleX)]; + Cr = component3Line[0 | (x * component3.scaleX * scaleX)]; + + R = clampTo8bit(Y + 1.402 * (Cr - 128)); + G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128)); + B = clampTo8bit(Y + 1.772 * (Cb - 128)); + } + + data[offset++] = R; + data[offset++] = G; + data[offset++] = B; + } + } + break; + case 4: + if (!this.adobe) + throw 'Unsupported color mode (4 components)'; + // The default transform for four components is false + colorTransform = false; + // The adobe transform marker overrides any previous setting + if (this.adobe && this.adobe.transformCode) + colorTransform = true; + else if (typeof this.colorTransform !== 'undefined') + colorTransform = !!this.colorTransform; + + component1 = this.components[0]; + component2 = this.components[1]; + component3 = this.components[2]; + component4 = this.components[3]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; + component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]; + component4Line = component4.lines[0 | (y * component4.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + if (!colorTransform) { + C = component1Line[0 | (x * component1.scaleX * scaleX)]; + M = component2Line[0 | (x * component2.scaleX * scaleX)]; + Ye = component3Line[0 | (x * component3.scaleX * scaleX)]; + K = component4Line[0 | (x * component4.scaleX * scaleX)]; + } else { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + Cb = component2Line[0 | (x * component2.scaleX * scaleX)]; + Cr = component3Line[0 | (x * component3.scaleX * scaleX)]; + K = component4Line[0 | (x * component4.scaleX * scaleX)]; + + C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128)); + M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128)); + Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128)); + } + data[offset++] = C; + data[offset++] = M; + data[offset++] = Ye; + data[offset++] = K; + } + } + break; + default: + throw 'Unsupported color mode'; + } + return data; + }, + copyToImageData: function copyToImageData(imageData) { + var width = imageData.width, height = imageData.height; + var imageDataArray = imageData.data; + var data = this.getData(width, height); + var i = 0, j = 0, x, y; + var Y, K, C, M, R, G, B; + switch (this.components.length) { + case 1: + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + Y = data[i++]; + + imageDataArray[j++] = Y; + imageDataArray[j++] = Y; + imageDataArray[j++] = Y; + imageDataArray[j++] = 255; + } + } + break; + case 3: + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + R = data[i++]; + G = data[i++]; + B = data[i++]; + + imageDataArray[j++] = R; + imageDataArray[j++] = G; + imageDataArray[j++] = B; + imageDataArray[j++] = 255; + } + } + break; + case 4: + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + C = data[i++]; + M = data[i++]; + Y = data[i++]; + K = data[i++]; + + R = 255 - clampTo8bit(C * (1 - K / 255) + K); + G = 255 - clampTo8bit(M * (1 - K / 255) + K); + B = 255 - clampTo8bit(Y * (1 - K / 255) + K); + + imageDataArray[j++] = R; + imageDataArray[j++] = G; + imageDataArray[j++] = B; + imageDataArray[j++] = 255; + } + } + break; + default: + throw 'Unsupported color mode'; + } + } + }; + + return constructor; +})(); +module.exports = decode; + +function decode(jpegData) { + var arr = new Uint8Array(jpegData); + var decoder = new JpegImage(); + decoder.parse(arr); + + var image = { + width: decoder.width, + height: decoder.height, + data: new Buffer(decoder.width * decoder.height * 4) + }; + + decoder.copyToImageData(image); + + return image; +} + +}).call(this,require("buffer").Buffer) +},{"buffer":5}],69:[function(require,module,exports){ +(function (Buffer){ +/* + Copyright (c) 2008, Adobe Systems Incorporated + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of Adobe Systems Incorporated nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/* +JPEG encoder ported to JavaScript and optimized by Andreas Ritter, www.bytestrom.eu, 11/2009 + +Basic GUI blocking jpeg encoder +*/ + +var btoa = btoa || function(buf) { + return new Buffer(buf).toString('base64'); +}; + +function JPEGEncoder(quality) { + var self = this; + var fround = Math.round; + var ffloor = Math.floor; + var YTable = new Array(64); + var UVTable = new Array(64); + var fdtbl_Y = new Array(64); + var fdtbl_UV = new Array(64); + var YDC_HT; + var UVDC_HT; + var YAC_HT; + var UVAC_HT; + + var bitcode = new Array(65535); + var category = new Array(65535); + var outputfDCTQuant = new Array(64); + var DU = new Array(64); + var byteout = []; + var bytenew = 0; + var bytepos = 7; + + var YDU = new Array(64); + var UDU = new Array(64); + var VDU = new Array(64); + var clt = new Array(256); + var RGB_YUV_TABLE = new Array(2048); + var currentQuality; + + var ZigZag = [ + 0, 1, 5, 6,14,15,27,28, + 2, 4, 7,13,16,26,29,42, + 3, 8,12,17,25,30,41,43, + 9,11,18,24,31,40,44,53, + 10,19,23,32,39,45,52,54, + 20,22,33,38,46,51,55,60, + 21,34,37,47,50,56,59,61, + 35,36,48,49,57,58,62,63 + ]; + + var std_dc_luminance_nrcodes = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0]; + var std_dc_luminance_values = [0,1,2,3,4,5,6,7,8,9,10,11]; + var std_ac_luminance_nrcodes = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d]; + var std_ac_luminance_values = [ + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12, + 0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07, + 0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0, + 0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16, + 0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39, + 0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49, + 0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69, + 0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79, + 0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98, + 0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7, + 0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5, + 0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4, + 0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea, + 0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8, + 0xf9,0xfa + ]; + + var std_dc_chrominance_nrcodes = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0]; + var std_dc_chrominance_values = [0,1,2,3,4,5,6,7,8,9,10,11]; + var std_ac_chrominance_nrcodes = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77]; + var std_ac_chrominance_values = [ + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21, + 0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71, + 0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0, + 0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34, + 0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38, + 0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48, + 0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68, + 0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78, + 0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96, + 0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5, + 0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3, + 0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2, + 0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9, + 0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8, + 0xf9,0xfa + ]; + + function initQuantTables(sf){ + var YQT = [ + 16, 11, 10, 16, 24, 40, 51, 61, + 12, 12, 14, 19, 26, 58, 60, 55, + 14, 13, 16, 24, 40, 57, 69, 56, + 14, 17, 22, 29, 51, 87, 80, 62, + 18, 22, 37, 56, 68,109,103, 77, + 24, 35, 55, 64, 81,104,113, 92, + 49, 64, 78, 87,103,121,120,101, + 72, 92, 95, 98,112,100,103, 99 + ]; + + for (var i = 0; i < 64; i++) { + var t = ffloor((YQT[i]*sf+50)/100); + if (t < 1) { + t = 1; + } else if (t > 255) { + t = 255; + } + YTable[ZigZag[i]] = t; + } + var UVQT = [ + 17, 18, 24, 47, 99, 99, 99, 99, + 18, 21, 26, 66, 99, 99, 99, 99, + 24, 26, 56, 99, 99, 99, 99, 99, + 47, 66, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99 + ]; + for (var j = 0; j < 64; j++) { + var u = ffloor((UVQT[j]*sf+50)/100); + if (u < 1) { + u = 1; + } else if (u > 255) { + u = 255; + } + UVTable[ZigZag[j]] = u; + } + var aasf = [ + 1.0, 1.387039845, 1.306562965, 1.175875602, + 1.0, 0.785694958, 0.541196100, 0.275899379 + ]; + var k = 0; + for (var row = 0; row < 8; row++) + { + for (var col = 0; col < 8; col++) + { + fdtbl_Y[k] = (1.0 / (YTable [ZigZag[k]] * aasf[row] * aasf[col] * 8.0)); + fdtbl_UV[k] = (1.0 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8.0)); + k++; + } + } + } + + function computeHuffmanTbl(nrcodes, std_table){ + var codevalue = 0; + var pos_in_table = 0; + var HT = new Array(); + for (var k = 1; k <= 16; k++) { + for (var j = 1; j <= nrcodes[k]; j++) { + HT[std_table[pos_in_table]] = []; + HT[std_table[pos_in_table]][0] = codevalue; + HT[std_table[pos_in_table]][1] = k; + pos_in_table++; + codevalue++; + } + codevalue*=2; + } + return HT; + } + + function initHuffmanTbl() + { + YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes,std_dc_luminance_values); + UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes,std_dc_chrominance_values); + YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes,std_ac_luminance_values); + UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes,std_ac_chrominance_values); + } + + function initCategoryNumber() + { + var nrlower = 1; + var nrupper = 2; + for (var cat = 1; cat <= 15; cat++) { + //Positive numbers + for (var nr = nrlower; nr>0] = 38470 * i; + RGB_YUV_TABLE[(i+ 512)>>0] = 7471 * i + 0x8000; + RGB_YUV_TABLE[(i+ 768)>>0] = -11059 * i; + RGB_YUV_TABLE[(i+1024)>>0] = -21709 * i; + RGB_YUV_TABLE[(i+1280)>>0] = 32768 * i + 0x807FFF; + RGB_YUV_TABLE[(i+1536)>>0] = -27439 * i; + RGB_YUV_TABLE[(i+1792)>>0] = - 5329 * i; + } + } + + // IO functions + function writeBits(bs) + { + var value = bs[0]; + var posval = bs[1]-1; + while ( posval >= 0 ) { + if (value & (1 << posval) ) { + bytenew |= (1 << bytepos); + } + posval--; + bytepos--; + if (bytepos < 0) { + if (bytenew == 0xFF) { + writeByte(0xFF); + writeByte(0); + } + else { + writeByte(bytenew); + } + bytepos=7; + bytenew=0; + } + } + } + + function writeByte(value) + { + //byteout.push(clt[value]); // write char directly instead of converting later + byteout.push(value); + } + + function writeWord(value) + { + writeByte((value>>8)&0xFF); + writeByte((value )&0xFF); + } + + // DCT & quantization core + function fDCTQuant(data, fdtbl) + { + var d0, d1, d2, d3, d4, d5, d6, d7; + /* Pass 1: process rows. */ + var dataOff=0; + var i; + const I8 = 8; + const I64 = 64; + for (i=0; i 0.0) ? ((fDCTQuant + 0.5)|0) : ((fDCTQuant - 0.5)|0); + //outputfDCTQuant[i] = fround(fDCTQuant); + + } + return outputfDCTQuant; + } + + function writeAPP0() + { + writeWord(0xFFE0); // marker + writeWord(16); // length + writeByte(0x4A); // J + writeByte(0x46); // F + writeByte(0x49); // I + writeByte(0x46); // F + writeByte(0); // = "JFIF",'\0' + writeByte(1); // versionhi + writeByte(1); // versionlo + writeByte(0); // xyunits + writeWord(1); // xdensity + writeWord(1); // ydensity + writeByte(0); // thumbnwidth + writeByte(0); // thumbnheight + } + + function writeSOF0(width, height) + { + writeWord(0xFFC0); // marker + writeWord(17); // length, truecolor YUV JPG + writeByte(8); // precision + writeWord(height); + writeWord(width); + writeByte(3); // nrofcomponents + writeByte(1); // IdY + writeByte(0x11); // HVY + writeByte(0); // QTY + writeByte(2); // IdU + writeByte(0x11); // HVU + writeByte(1); // QTU + writeByte(3); // IdV + writeByte(0x11); // HVV + writeByte(1); // QTV + } + + function writeDQT() + { + writeWord(0xFFDB); // marker + writeWord(132); // length + writeByte(0); + for (var i=0; i<64; i++) { + writeByte(YTable[i]); + } + writeByte(1); + for (var j=0; j<64; j++) { + writeByte(UVTable[j]); + } + } + + function writeDHT() + { + writeWord(0xFFC4); // marker + writeWord(0x01A2); // length + + writeByte(0); // HTYDCinfo + for (var i=0; i<16; i++) { + writeByte(std_dc_luminance_nrcodes[i+1]); + } + for (var j=0; j<=11; j++) { + writeByte(std_dc_luminance_values[j]); + } + + writeByte(0x10); // HTYACinfo + for (var k=0; k<16; k++) { + writeByte(std_ac_luminance_nrcodes[k+1]); + } + for (var l=0; l<=161; l++) { + writeByte(std_ac_luminance_values[l]); + } + + writeByte(1); // HTUDCinfo + for (var m=0; m<16; m++) { + writeByte(std_dc_chrominance_nrcodes[m+1]); + } + for (var n=0; n<=11; n++) { + writeByte(std_dc_chrominance_values[n]); + } + + writeByte(0x11); // HTUACinfo + for (var o=0; o<16; o++) { + writeByte(std_ac_chrominance_nrcodes[o+1]); + } + for (var p=0; p<=161; p++) { + writeByte(std_ac_chrominance_values[p]); + } + } + + function writeSOS() + { + writeWord(0xFFDA); // marker + writeWord(12); // length + writeByte(3); // nrofcomponents + writeByte(1); // IdY + writeByte(0); // HTY + writeByte(2); // IdU + writeByte(0x11); // HTU + writeByte(3); // IdV + writeByte(0x11); // HTV + writeByte(0); // Ss + writeByte(0x3f); // Se + writeByte(0); // Bf + } + + function processDU(CDU, fdtbl, DC, HTDC, HTAC){ + var EOB = HTAC[0x00]; + var M16zeroes = HTAC[0xF0]; + var pos; + const I16 = 16; + const I63 = 63; + const I64 = 64; + var DU_DCT = fDCTQuant(CDU, fdtbl); + //ZigZag reorder + for (var j=0;j0)&&(DU[end0pos]==0); end0pos--) {}; + //end0pos = first element in reverse order !=0 + if ( end0pos == 0) { + writeBits(EOB); + return DC; + } + var i = 1; + var lng; + while ( i <= end0pos ) { + var startpos = i; + for (; (DU[i]==0) && (i<=end0pos); ++i) {} + var nrzeroes = i-startpos; + if ( nrzeroes >= I16 ) { + lng = nrzeroes>>4; + for (var nrmarker=1; nrmarker <= lng; ++nrmarker) + writeBits(M16zeroes); + nrzeroes = nrzeroes&0xF; + } + pos = 32767+DU[i]; + writeBits(HTAC[(nrzeroes<<4)+category[pos]]); + writeBits(bitcode[pos]); + i++; + } + if ( end0pos != I63 ) { + writeBits(EOB); + } + return DC; + } + + function initCharLookupTable(){ + var sfcc = String.fromCharCode; + for(var i=0; i < 256; i++){ ///// ACHTUNG // 255 + clt[i] = sfcc(i); + } + } + + this.encode = function(image,quality) // image data object + { + var time_start = new Date().getTime(); + + if(quality) setQuality(quality); + + // Initialize bit writer + byteout = new Array(); + bytenew=0; + bytepos=7; + + // Add JPEG headers + writeWord(0xFFD8); // SOI + writeAPP0(); + writeDQT(); + writeSOF0(image.width,image.height); + writeDHT(); + writeSOS(); + + + // Encode 8x8 macroblocks + var DCY=0; + var DCU=0; + var DCV=0; + + bytenew=0; + bytepos=7; + + + this.encode.displayName = "_encode_"; + + var imageData = image.data; + var width = image.width; + var height = image.height; + + var quadWidth = width*4; + var tripleWidth = width*3; + + var x, y = 0; + var r, g, b; + var start,p, col,row,pos; + while(y < height){ + x = 0; + while(x < quadWidth){ + start = quadWidth * y + x; + p = start; + col = -1; + row = 0; + + for(pos=0; pos < 64; pos++){ + row = pos >> 3;// /8 + col = ( pos & 7 ) * 4; // %8 + p = start + ( row * quadWidth ) + col; + + if(y+row >= height){ // padding bottom + p-= (quadWidth*(y+1+row-height)); + } + + if(x+col >= quadWidth){ // padding right + p-= ((x+col) - quadWidth +4) + } + + r = imageData[ p++ ]; + g = imageData[ p++ ]; + b = imageData[ p++ ]; + + + /* // calculate YUV values dynamically + YDU[pos]=((( 0.29900)*r+( 0.58700)*g+( 0.11400)*b))-128; //-0x80 + UDU[pos]=(((-0.16874)*r+(-0.33126)*g+( 0.50000)*b)); + VDU[pos]=((( 0.50000)*r+(-0.41869)*g+(-0.08131)*b)); + */ + + // use lookup table (slightly faster) + YDU[pos] = ((RGB_YUV_TABLE[r] + RGB_YUV_TABLE[(g + 256)>>0] + RGB_YUV_TABLE[(b + 512)>>0]) >> 16)-128; + UDU[pos] = ((RGB_YUV_TABLE[(r + 768)>>0] + RGB_YUV_TABLE[(g + 1024)>>0] + RGB_YUV_TABLE[(b + 1280)>>0]) >> 16)-128; + VDU[pos] = ((RGB_YUV_TABLE[(r + 1280)>>0] + RGB_YUV_TABLE[(g + 1536)>>0] + RGB_YUV_TABLE[(b + 1792)>>0]) >> 16)-128; + + } + + DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + x+=32; + } + y+=8; + } + + + //////////////////////////////////////////////////////////////// + + // Do the bit alignment of the EOI marker + if ( bytepos >= 0 ) { + var fillbits = []; + fillbits[1] = bytepos+1; + fillbits[0] = (1<<(bytepos+1))-1; + writeBits(fillbits); + } + + writeWord(0xFFD9); //EOI + + //return new Uint8Array(byteout); + return new Buffer(byteout); + + var jpegDataUri = 'data:image/jpeg;base64,' + btoa(byteout.join('')); + + byteout = []; + + // benchmarking + var duration = new Date().getTime() - time_start; + //console.log('Encoding time: '+ duration + 'ms'); + // + + return jpegDataUri + } + + function setQuality(quality){ + if (quality <= 0) { + quality = 1; + } + if (quality > 100) { + quality = 100; + } + + if(currentQuality == quality) return // don't recalc if unchanged + + var sf = 0; + if (quality < 50) { + sf = Math.floor(5000 / quality); + } else { + sf = Math.floor(200 - quality*2); + } + + initQuantTables(sf); + currentQuality = quality; + //console.log('Quality set to: '+quality +'%'); + } + + function init(){ + var time_start = new Date().getTime(); + if(!quality) quality = 50; + // Create tables + initCharLookupTable() + initHuffmanTbl(); + initCategoryNumber(); + initRGBYUVTable(); + + setQuality(quality); + var duration = new Date().getTime() - time_start; + //console.log('Initialization '+ duration + 'ms'); + } + + init(); + +}; +module.exports = encode; + +function encode(imgData, qu) { + if (typeof qu === 'undefined') qu = 50; + var encoder = new JPEGEncoder(qu); + var data = encoder.encode(imgData, qu); + return { + data: data, + width: imgData.width, + height: imgData.height + }; +} + +// helper function to get the imageData of an existing image on the current page. +function getImageDataFromImage(idOrElement){ + var theImg = (typeof(idOrElement)=='string')? document.getElementById(idOrElement):idOrElement; + var cvs = document.createElement('canvas'); + cvs.width = theImg.width; + cvs.height = theImg.height; + var ctx = cvs.getContext("2d"); + ctx.drawImage(theImg,0,0); + + return (ctx.getImageData(0, 0, cvs.width, cvs.height)); +} + +}).call(this,require("buffer").Buffer) +},{"buffer":5}],70:[function(require,module,exports){ +arguments[4][42][0].apply(exports,arguments) +},{"dup":42}],71:[function(require,module,exports){ "use strict" function iota(n) { @@ -15623,7 +25417,7 @@ function iota(n) { } module.exports = iota -},{}],59:[function(require,module,exports){ +},{}],72:[function(require,module,exports){ /*! * Determine if an object is a Buffer * @@ -15646,14 +25440,12 @@ function isSlowBuffer (obj) { return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) } -},{}],60:[function(require,module,exports){ -var toString = {}.toString; - +},{}],73:[function(require,module,exports){ module.exports = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; + return Object.prototype.toString.call(arr) == '[object Array]'; }; -},{}],61:[function(require,module,exports){ +},{}],74:[function(require,module,exports){ (function webpackUniversalModuleDefinition(root, factory) { if(typeof exports === 'object' && typeof module === 'object') module.exports = factory(); @@ -15710,2676 +25502,2676 @@ return /******/ (function(modules) { // webpackBootstrap /* 0 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - /// - var binarizer_1 = __webpack_require__(1); - var locator_1 = __webpack_require__(3); - var extractor_1 = __webpack_require__(4); - var decoder_1 = __webpack_require__(9); - var bitmatrix_1 = __webpack_require__(2); - var binarizeImage = binarizer_1.binarize; - exports.binarizeImage = binarizeImage; - var locateQRInBinaryImage = locator_1.locate; - exports.locateQRInBinaryImage = locateQRInBinaryImage; - var extractQRFromBinaryImage = extractor_1.extract; - exports.extractQRFromBinaryImage = extractQRFromBinaryImage; - function decodeQR(matrix) { - return byteArrayToString(decoder_1.decode(matrix)); - } - exports.decodeQR = decodeQR; - // return bytes.reduce((p, b) => p + String.fromCharCode(b), ""); - function byteArrayToString(bytes) { - var str = ""; - if (bytes != null && bytes != undefined) { - for (var i = 0; i < bytes.length; i++) { - str += String.fromCharCode(bytes[i]); - } - } - return str; - } - function createBitMatrix(data, width) { - return new bitmatrix_1.BitMatrix(data, width); - } - exports.createBitMatrix = createBitMatrix; - function decodeQRFromImage(data, width, height) { - return byteArrayToString(decodeQRFromImageAsByteArray(data, width, height)); - } - exports.decodeQRFromImage = decodeQRFromImage; - function decodeQRFromImageAsByteArray(data, width, height) { - var binarizedImage = binarizeImage(data, width, height); - var location = locator_1.locate(binarizedImage); - if (!location) { - return null; - } - var rawQR = extractor_1.extract(binarizedImage, location); - if (!rawQR) { - return null; - } - return decoder_1.decode(rawQR); - } - exports.decodeQRFromImageAsByteArray = decodeQRFromImageAsByteArray; + "use strict"; + /// + var binarizer_1 = __webpack_require__(1); + var locator_1 = __webpack_require__(3); + var extractor_1 = __webpack_require__(4); + var decoder_1 = __webpack_require__(9); + var bitmatrix_1 = __webpack_require__(2); + var binarizeImage = binarizer_1.binarize; + exports.binarizeImage = binarizeImage; + var locateQRInBinaryImage = locator_1.locate; + exports.locateQRInBinaryImage = locateQRInBinaryImage; + var extractQRFromBinaryImage = extractor_1.extract; + exports.extractQRFromBinaryImage = extractQRFromBinaryImage; + function decodeQR(matrix) { + return byteArrayToString(decoder_1.decode(matrix)); + } + exports.decodeQR = decodeQR; + // return bytes.reduce((p, b) => p + String.fromCharCode(b), ""); + function byteArrayToString(bytes) { + var str = ""; + if (bytes != null && bytes != undefined) { + for (var i = 0; i < bytes.length; i++) { + str += String.fromCharCode(bytes[i]); + } + } + return str; + } + function createBitMatrix(data, width) { + return new bitmatrix_1.BitMatrix(data, width); + } + exports.createBitMatrix = createBitMatrix; + function decodeQRFromImage(data, width, height) { + return byteArrayToString(decodeQRFromImageAsByteArray(data, width, height)); + } + exports.decodeQRFromImage = decodeQRFromImage; + function decodeQRFromImageAsByteArray(data, width, height) { + var binarizedImage = binarizeImage(data, width, height); + var location = locator_1.locate(binarizedImage); + if (!location) { + return null; + } + var rawQR = extractor_1.extract(binarizedImage, location); + if (!rawQR) { + return null; + } + return decoder_1.decode(rawQR); + } + exports.decodeQRFromImageAsByteArray = decodeQRFromImageAsByteArray; /***/ }, /* 1 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - var bitmatrix_1 = __webpack_require__(2); - // Magic Constants - var BLOCK_SIZE_POWER = 3; - var BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; - var BLOCK_SIZE_MASK = BLOCK_SIZE - 1; - var MIN_DYNAMIC_RANGE = 24; - function calculateBlackPoints(luminances, subWidth, subHeight, width, height) { - var blackPoints = new Array(subHeight); - for (var i = 0; i < subHeight; i++) { - blackPoints[i] = new Array(subWidth); - } - for (var y = 0; y < subHeight; y++) { - var yoffset = y << BLOCK_SIZE_POWER; - var maxYOffset = height - BLOCK_SIZE; - if (yoffset > maxYOffset) { - yoffset = maxYOffset; - } - for (var x = 0; x < subWidth; x++) { - var xoffset = x << BLOCK_SIZE_POWER; - var maxXOffset = width - BLOCK_SIZE; - if (xoffset > maxXOffset) { - xoffset = maxXOffset; - } - var sum = 0; - var min = 0xFF; - var max = 0; - for (var yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width) { - for (var xx = 0; xx < BLOCK_SIZE; xx++) { - var pixel = luminances[offset + xx] & 0xFF; - // still looking for good contrast - sum += pixel; - if (pixel < min) { - min = pixel; - } - if (pixel > max) { - max = pixel; - } - } - // short-circuit min/max tests once dynamic range is met - if (max - min > MIN_DYNAMIC_RANGE) { - // finish the rest of the rows quickly - for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) { - for (var xx = 0; xx < BLOCK_SIZE; xx++) { - sum += luminances[offset + xx] & 0xFF; - } - } - } - } - // The default estimate is the average of the values in the block. - var average = sum >> (BLOCK_SIZE_POWER * 2); - if (max - min <= MIN_DYNAMIC_RANGE) { - // If variation within the block is low, assume this is a block with only light or only - // dark pixels. In that case we do not want to use the average, as it would divide this - // low contrast area into black and white pixels, essentially creating data out of noise. - // - // The default assumption is that the block is light/background. Since no estimate for - // the level of dark pixels exists locally, use half the min for the block. - average = min >> 1; - if (y > 0 && x > 0) { - // Correct the "white background" assumption for blocks that have neighbors by comparing - // the pixels in this block to the previously calculated black points. This is based on - // the fact that dark barcode symbology is always surrounded by some amount of light - // background for which reasonable black point estimates were made. The bp estimated at - // the boundaries is used for the interior. - // The (min < bp) is arbitrary but works better than other heuristics that were tried. - var averageNeighborBlackPoint = (blackPoints[y - 1][x] + (2 * blackPoints[y][x - 1]) + blackPoints[y - 1][x - 1]) >> 2; - if (min < averageNeighborBlackPoint) { - average = averageNeighborBlackPoint; - } - } - } - blackPoints[y][x] = average; - } - } - return blackPoints; - } - function calculateThresholdForBlock(luminances, subWidth, subHeight, width, height, blackPoints) { - function cap(value, min, max) { - return value < min ? min : value > max ? max : value; - } - // var outArray = new Array(width * height); - var outMatrix = bitmatrix_1.BitMatrix.createEmpty(width, height); - function thresholdBlock(luminances, xoffset, yoffset, threshold, stride) { - var offset = (yoffset * stride) + xoffset; - for (var y = 0; y < BLOCK_SIZE; y++, offset += stride) { - for (var x = 0; x < BLOCK_SIZE; x++) { - var pixel = luminances[offset + x] & 0xff; - // Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0. - outMatrix.set(xoffset + x, yoffset + y, pixel <= threshold); - } - } - } - for (var y = 0; y < subHeight; y++) { - var yoffset = y << BLOCK_SIZE_POWER; - var maxYOffset = height - BLOCK_SIZE; - if (yoffset > maxYOffset) { - yoffset = maxYOffset; - } - for (var x = 0; x < subWidth; x++) { - var xoffset = x << BLOCK_SIZE_POWER; - var maxXOffset = width - BLOCK_SIZE; - if (xoffset > maxXOffset) { - xoffset = maxXOffset; - } - var left = cap(x, 2, subWidth - 3); - var top = cap(y, 2, subHeight - 3); - var sum = 0; - for (var z = -2; z <= 2; z++) { - var blackRow = blackPoints[top + z]; - sum += blackRow[left - 2]; - sum += blackRow[left - 1]; - sum += blackRow[left]; - sum += blackRow[left + 1]; - sum += blackRow[left + 2]; - } - var average = sum / 25; - thresholdBlock(luminances, xoffset, yoffset, average, width); - } - } - return outMatrix; - } - function binarize(data, width, height) { - if (data.length !== width * height * 4) { - throw new Error("Binarizer data.length != width * height * 4"); - } - var gsArray = new Array(width * height); - for (var x = 0; x < width; x++) { - for (var y = 0; y < height; y++) { - var startIndex = (y * width + x) * 4; - var r = data[startIndex]; - var g = data[startIndex + 1]; - var b = data[startIndex + 2]; - // Magic lumosity constants - var lum = 0.2126 * r + 0.7152 * g + 0.0722 * b; - gsArray[y * width + x] = lum; - } - } - var subWidth = width >> BLOCK_SIZE_POWER; - if ((width & BLOCK_SIZE_MASK) != 0) { - subWidth++; - } - var subHeight = height >> BLOCK_SIZE_POWER; - if ((height & BLOCK_SIZE_MASK) != 0) { - subHeight++; - } - var blackPoints = calculateBlackPoints(gsArray, subWidth, subHeight, width, height); - return calculateThresholdForBlock(gsArray, subWidth, subHeight, width, height, blackPoints); - } - exports.binarize = binarize; + "use strict"; + var bitmatrix_1 = __webpack_require__(2); + // Magic Constants + var BLOCK_SIZE_POWER = 3; + var BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; + var BLOCK_SIZE_MASK = BLOCK_SIZE - 1; + var MIN_DYNAMIC_RANGE = 24; + function calculateBlackPoints(luminances, subWidth, subHeight, width, height) { + var blackPoints = new Array(subHeight); + for (var i = 0; i < subHeight; i++) { + blackPoints[i] = new Array(subWidth); + } + for (var y = 0; y < subHeight; y++) { + var yoffset = y << BLOCK_SIZE_POWER; + var maxYOffset = height - BLOCK_SIZE; + if (yoffset > maxYOffset) { + yoffset = maxYOffset; + } + for (var x = 0; x < subWidth; x++) { + var xoffset = x << BLOCK_SIZE_POWER; + var maxXOffset = width - BLOCK_SIZE; + if (xoffset > maxXOffset) { + xoffset = maxXOffset; + } + var sum = 0; + var min = 0xFF; + var max = 0; + for (var yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width) { + for (var xx = 0; xx < BLOCK_SIZE; xx++) { + var pixel = luminances[offset + xx] & 0xFF; + // still looking for good contrast + sum += pixel; + if (pixel < min) { + min = pixel; + } + if (pixel > max) { + max = pixel; + } + } + // short-circuit min/max tests once dynamic range is met + if (max - min > MIN_DYNAMIC_RANGE) { + // finish the rest of the rows quickly + for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) { + for (var xx = 0; xx < BLOCK_SIZE; xx++) { + sum += luminances[offset + xx] & 0xFF; + } + } + } + } + // The default estimate is the average of the values in the block. + var average = sum >> (BLOCK_SIZE_POWER * 2); + if (max - min <= MIN_DYNAMIC_RANGE) { + // If variation within the block is low, assume this is a block with only light or only + // dark pixels. In that case we do not want to use the average, as it would divide this + // low contrast area into black and white pixels, essentially creating data out of noise. + // + // The default assumption is that the block is light/background. Since no estimate for + // the level of dark pixels exists locally, use half the min for the block. + average = min >> 1; + if (y > 0 && x > 0) { + // Correct the "white background" assumption for blocks that have neighbors by comparing + // the pixels in this block to the previously calculated black points. This is based on + // the fact that dark barcode symbology is always surrounded by some amount of light + // background for which reasonable black point estimates were made. The bp estimated at + // the boundaries is used for the interior. + // The (min < bp) is arbitrary but works better than other heuristics that were tried. + var averageNeighborBlackPoint = (blackPoints[y - 1][x] + (2 * blackPoints[y][x - 1]) + blackPoints[y - 1][x - 1]) >> 2; + if (min < averageNeighborBlackPoint) { + average = averageNeighborBlackPoint; + } + } + } + blackPoints[y][x] = average; + } + } + return blackPoints; + } + function calculateThresholdForBlock(luminances, subWidth, subHeight, width, height, blackPoints) { + function cap(value, min, max) { + return value < min ? min : value > max ? max : value; + } + // var outArray = new Array(width * height); + var outMatrix = bitmatrix_1.BitMatrix.createEmpty(width, height); + function thresholdBlock(luminances, xoffset, yoffset, threshold, stride) { + var offset = (yoffset * stride) + xoffset; + for (var y = 0; y < BLOCK_SIZE; y++, offset += stride) { + for (var x = 0; x < BLOCK_SIZE; x++) { + var pixel = luminances[offset + x] & 0xff; + // Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0. + outMatrix.set(xoffset + x, yoffset + y, pixel <= threshold); + } + } + } + for (var y = 0; y < subHeight; y++) { + var yoffset = y << BLOCK_SIZE_POWER; + var maxYOffset = height - BLOCK_SIZE; + if (yoffset > maxYOffset) { + yoffset = maxYOffset; + } + for (var x = 0; x < subWidth; x++) { + var xoffset = x << BLOCK_SIZE_POWER; + var maxXOffset = width - BLOCK_SIZE; + if (xoffset > maxXOffset) { + xoffset = maxXOffset; + } + var left = cap(x, 2, subWidth - 3); + var top = cap(y, 2, subHeight - 3); + var sum = 0; + for (var z = -2; z <= 2; z++) { + var blackRow = blackPoints[top + z]; + sum += blackRow[left - 2]; + sum += blackRow[left - 1]; + sum += blackRow[left]; + sum += blackRow[left + 1]; + sum += blackRow[left + 2]; + } + var average = sum / 25; + thresholdBlock(luminances, xoffset, yoffset, average, width); + } + } + return outMatrix; + } + function binarize(data, width, height) { + if (data.length !== width * height * 4) { + throw new Error("Binarizer data.length != width * height * 4"); + } + var gsArray = new Array(width * height); + for (var x = 0; x < width; x++) { + for (var y = 0; y < height; y++) { + var startIndex = (y * width + x) * 4; + var r = data[startIndex]; + var g = data[startIndex + 1]; + var b = data[startIndex + 2]; + // Magic lumosity constants + var lum = 0.2126 * r + 0.7152 * g + 0.0722 * b; + gsArray[y * width + x] = lum; + } + } + var subWidth = width >> BLOCK_SIZE_POWER; + if ((width & BLOCK_SIZE_MASK) != 0) { + subWidth++; + } + var subHeight = height >> BLOCK_SIZE_POWER; + if ((height & BLOCK_SIZE_MASK) != 0) { + subHeight++; + } + var blackPoints = calculateBlackPoints(gsArray, subWidth, subHeight, width, height); + return calculateThresholdForBlock(gsArray, subWidth, subHeight, width, height, blackPoints); + } + exports.binarize = binarize; /***/ }, /* 2 */ /***/ function(module, exports) { - "use strict"; - var BitMatrix = (function () { - function BitMatrix(data, width) { - this.width = width; - this.height = data.length / width; - this.data = data; - } - BitMatrix.createEmpty = function (width, height) { - var data = new Array(width * height); - for (var i = 0; i < data.length; i++) { - data[i] = false; - } - return new BitMatrix(data, width); - }; - BitMatrix.prototype.get = function (x, y) { - return this.data[y * this.width + x]; - }; - BitMatrix.prototype.set = function (x, y, v) { - this.data[y * this.width + x] = v; - }; - BitMatrix.prototype.copyBit = function (x, y, versionBits) { - return this.get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1; - }; - BitMatrix.prototype.setRegion = function (left, top, width, height) { - var right = left + width; - var bottom = top + height; - for (var y = top; y < bottom; y++) { - for (var x = left; x < right; x++) { - this.set(x, y, true); - } - } - }; - BitMatrix.prototype.mirror = function () { - for (var x = 0; x < this.width; x++) { - for (var y = x + 1; y < this.height; y++) { - if (this.get(x, y) != this.get(y, x)) { - this.set(x, y, !this.get(x, y)); - this.set(y, x, !this.get(y, x)); - } - } - } - }; - return BitMatrix; - }()); - exports.BitMatrix = BitMatrix; + "use strict"; + var BitMatrix = (function () { + function BitMatrix(data, width) { + this.width = width; + this.height = data.length / width; + this.data = data; + } + BitMatrix.createEmpty = function (width, height) { + var data = new Array(width * height); + for (var i = 0; i < data.length; i++) { + data[i] = false; + } + return new BitMatrix(data, width); + }; + BitMatrix.prototype.get = function (x, y) { + return this.data[y * this.width + x]; + }; + BitMatrix.prototype.set = function (x, y, v) { + this.data[y * this.width + x] = v; + }; + BitMatrix.prototype.copyBit = function (x, y, versionBits) { + return this.get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1; + }; + BitMatrix.prototype.setRegion = function (left, top, width, height) { + var right = left + width; + var bottom = top + height; + for (var y = top; y < bottom; y++) { + for (var x = left; x < right; x++) { + this.set(x, y, true); + } + } + }; + BitMatrix.prototype.mirror = function () { + for (var x = 0; x < this.width; x++) { + for (var y = x + 1; y < this.height; y++) { + if (this.get(x, y) != this.get(y, x)) { + this.set(x, y, !this.get(x, y)); + this.set(y, x, !this.get(y, x)); + } + } + } + }; + return BitMatrix; + }()); + exports.BitMatrix = BitMatrix; /***/ }, /* 3 */ /***/ function(module, exports) { - "use strict"; - var CENTER_QUORUM = 2; - var MIN_SKIP = 3; - var MAX_MODULES = 57; - var INTEGER_MATH_SHIFT = 8; - var FinderPattern = (function () { - function FinderPattern(x, y, estimatedModuleSize, count) { - this.x = x; - this.y = y; - this.estimatedModuleSize = estimatedModuleSize; - if (count == null) { - this.count = 1; - } - else { - this.count = count; - } - } - FinderPattern.prototype.aboutEquals = function (moduleSize, i, j) { - if (Math.abs(i - this.y) <= moduleSize && Math.abs(j - this.x) <= moduleSize) { - var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize); - return moduleSizeDiff <= 1.0 || moduleSizeDiff <= this.estimatedModuleSize; - } - return false; - }; - FinderPattern.prototype.combineEstimate = function (i, j, newModuleSize) { - var combinedCount = this.count + 1; - var combinedX = (this.count * this.x + j) / combinedCount; - var combinedY = (this.count * this.y + i) / combinedCount; - var combinedModuleSize = (this.count * this.estimatedModuleSize + newModuleSize) / combinedCount; - return new FinderPattern(combinedX, combinedY, combinedModuleSize, combinedCount); - }; - return FinderPattern; - }()); - function foundPatternCross(stateCount) { - var totalModuleSize = 0; - for (var i = 0; i < 5; i++) { - var count = stateCount[i]; - if (count === 0) - return false; - totalModuleSize += count; - } - if (totalModuleSize < 7) - return false; - var moduleSize = (totalModuleSize << INTEGER_MATH_SHIFT) / 7; - var maxVariance = moduleSize / 2; - // Allow less than 50% variance from 1-1-3-1-1 proportions - return Math.abs(moduleSize - (stateCount[0] << INTEGER_MATH_SHIFT)) < maxVariance && - Math.abs(moduleSize - (stateCount[1] << INTEGER_MATH_SHIFT)) < maxVariance && - Math.abs(3 * moduleSize - (stateCount[2] << INTEGER_MATH_SHIFT)) < 3 * maxVariance && - Math.abs(moduleSize - (stateCount[3] << INTEGER_MATH_SHIFT)) < maxVariance && - Math.abs(moduleSize - (stateCount[4] << INTEGER_MATH_SHIFT)) < maxVariance; - } - function centerFromEnd(stateCount, end) { - var result = (end - stateCount[4] - stateCount[3]) - stateCount[2] / 2; - // Fix this. - if (result !== result) { - return null; - } - return result; - } - function distance(pattern1, pattern2) { - var a = pattern1.x - pattern2.x; - var b = pattern1.y - pattern2.y; - return Math.sqrt(a * a + b * b); - } - function crossProductZ(pointA, pointB, pointC) { - var bX = pointB.x; - var bY = pointB.y; - return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX)); - } - function ReorderFinderPattern(patterns) { - // Find distances between pattern centers - var zeroOneDistance = distance(patterns[0], patterns[1]); - var oneTwoDistance = distance(patterns[1], patterns[2]); - var zeroTwoDistance = distance(patterns[0], patterns[2]); - var pointA, pointB, pointC; - // Assume one closest to other two is B; A and C will just be guesses at first - if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) { - pointB = patterns[0]; - pointA = patterns[1]; - pointC = patterns[2]; - } - else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) { - pointB = patterns[1]; - pointA = patterns[0]; - pointC = patterns[2]; - } - else { - pointB = patterns[2]; - pointA = patterns[0]; - pointC = patterns[1]; - } - // Use cross product to figure out whether A and C are correct or flipped. - // This asks whether BC x BA has a positive z component, which is the arrangement - // we want for A, B, C. If it's negative, then we've got it flipped around and - // should swap A and C. - if (crossProductZ(pointA, pointB, pointC) < 0) { - var temp = pointA; - pointA = pointC; - pointC = temp; - } - return { - bottomLeft: { x: pointA.x, y: pointA.y }, - topLeft: { x: pointB.x, y: pointB.y }, - topRight: { x: pointC.x, y: pointC.y } - }; - } - function locate(matrix) { - // Global state :( - var possibleCenters = []; - var hasSkipped = false; - function get(x, y) { - x = Math.floor(x); - y = Math.floor(y); - return matrix.get(x, y); - } - // Methods - function crossCheckDiagonal(startI, centerJ, maxCount, originalStateCountTotal) { - var maxI = matrix.height; - var maxJ = matrix.width; - var stateCount = [0, 0, 0, 0, 0]; - // Start counting up, left from center finding black center mass - var i = 0; - while (startI - i >= 0 && get(centerJ - i, startI - i)) { - stateCount[2]++; - i++; - } - if ((startI - i < 0) || (centerJ - i < 0)) { - return false; - } - // Continue up, left finding white space - while ((startI - i >= 0) && (centerJ - i >= 0) && !get(centerJ - i, startI - i) && stateCount[1] <= maxCount) { - stateCount[1]++; - i++; - } - // If already too many modules in this state or ran off the edge: - if ((startI - i < 0) || (centerJ - i < 0) || stateCount[1] > maxCount) { - return false; - } - // Continue up, left finding black border - while ((startI - i >= 0) && (centerJ - i >= 0) && get(centerJ - i, startI - i) && stateCount[0] <= maxCount) { - stateCount[0]++; - i++; - } - if (stateCount[0] > maxCount) { - return false; - } - // Now also count down, right from center - i = 1; - while ((startI + i < maxI) && (centerJ + i < maxJ) && get(centerJ + i, startI + i)) { - stateCount[2]++; - i++; - } - // Ran off the edge? - if ((startI + i >= maxI) || (centerJ + i >= maxJ)) { - return false; - } - while ((startI + i < maxI) && (centerJ + i < maxJ) && !get(centerJ + i, startI + i) && stateCount[3] < maxCount) { - stateCount[3]++; - i++; - } - if ((startI + i >= maxI) || (centerJ + i >= maxJ) || stateCount[3] >= maxCount) { - return false; - } - while ((startI + i < maxI) && (centerJ + i < maxJ) && get(centerJ + i, startI + i) && stateCount[4] < maxCount) { - stateCount[4]++; - i++; - } - if (stateCount[4] >= maxCount) { - return false; - } - // If we found a finder-pattern-like section, but its size is more than 100% different than - // the original, assume it's a false positive - var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; - return Math.abs(stateCountTotal - originalStateCountTotal) < 2 * originalStateCountTotal && - foundPatternCross(stateCount); - } - function crossCheckVertical(startI, centerJ, maxCount, originalStateCountTotal) { - var maxI = matrix.height; - var stateCount = [0, 0, 0, 0, 0]; - // Start counting up from center - var i = startI; - while (i >= 0 && get(centerJ, i)) { - stateCount[2]++; - i--; - } - if (i < 0) { - return null; - } - while (i >= 0 && !get(centerJ, i) && stateCount[1] <= maxCount) { - stateCount[1]++; - i--; - } - // If already too many modules in this state or ran off the edge: - if (i < 0 || stateCount[1] > maxCount) { - return null; - } - while (i >= 0 && get(centerJ, i) && stateCount[0] <= maxCount) { - stateCount[0]++; - i--; - } - if (stateCount[0] > maxCount) { - return null; - } - // Now also count down from center - i = startI + 1; - while (i < maxI && get(centerJ, i)) { - stateCount[2]++; - i++; - } - if (i == maxI) { - return null; - } - while (i < maxI && !get(centerJ, i) && stateCount[3] < maxCount) { - stateCount[3]++; - i++; - } - if (i == maxI || stateCount[3] >= maxCount) { - return null; - } - while (i < maxI && get(centerJ, i) && stateCount[4] < maxCount) { - stateCount[4]++; - i++; - } - if (stateCount[4] >= maxCount) { - return null; - } - // If we found a finder-pattern-like section, but its size is more than 40% different than - // the original, assume it's a false positive - var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; - if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) { - return null; - } - return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : null; - } - function haveMultiplyConfirmedCenters() { - var confirmedCount = 0; - var totalModuleSize = 0; - var max = possibleCenters.length; - possibleCenters.forEach(function (pattern) { - if (pattern.count >= CENTER_QUORUM) { - confirmedCount++; - totalModuleSize += pattern.estimatedModuleSize; - } - }); - if (confirmedCount < 3) { - return false; - } - // OK, we have at least 3 confirmed centers, but, it's possible that one is a "false positive" - // and that we need to keep looking. We detect this by asking if the estimated module sizes - // vary too much. We arbitrarily say that when the total deviation from average exceeds - // 5% of the total module size estimates, it's too much. - var average = totalModuleSize / max; - var totalDeviation = 0; - for (var i = 0; i < max; i++) { - var pattern = possibleCenters[i]; - totalDeviation += Math.abs(pattern.estimatedModuleSize - average); - } - return totalDeviation <= 0.05 * totalModuleSize; - } - function crossCheckHorizontal(startJ, centerI, maxCount, originalStateCountTotal) { - var maxJ = matrix.width; - var stateCount = [0, 0, 0, 0, 0]; - var j = startJ; - while (j >= 0 && get(j, centerI)) { - stateCount[2]++; - j--; - } - if (j < 0) { - return null; - } - while (j >= 0 && !get(j, centerI) && stateCount[1] <= maxCount) { - stateCount[1]++; - j--; - } - if (j < 0 || stateCount[1] > maxCount) { - return null; - } - while (j >= 0 && get(j, centerI) && stateCount[0] <= maxCount) { - stateCount[0]++; - j--; - } - if (stateCount[0] > maxCount) { - return null; - } - j = startJ + 1; - while (j < maxJ && get(j, centerI)) { - stateCount[2]++; - j++; - } - if (j == maxJ) { - return null; - } - while (j < maxJ && !get(j, centerI) && stateCount[3] < maxCount) { - stateCount[3]++; - j++; - } - if (j == maxJ || stateCount[3] >= maxCount) { - return null; - } - while (j < maxJ && get(j, centerI) && stateCount[4] < maxCount) { - stateCount[4]++; - j++; - } - if (stateCount[4] >= maxCount) { - return null; - } - // If we found a finder-pattern-like section, but its size is significantly different than - // the original, assume it's a false positive - var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; - if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) { - return null; - } - return foundPatternCross(stateCount) ? centerFromEnd(stateCount, j) : null; - } - function handlePossibleCenter(stateCount, i, j, pureBarcode) { - var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; - var centerJ = centerFromEnd(stateCount, j); - if (centerJ == null) - return false; - var centerI = crossCheckVertical(i, Math.floor(centerJ), stateCount[2], stateCountTotal); - if (centerI != null) { - // Re-cross check - centerJ = crossCheckHorizontal(Math.floor(centerJ), Math.floor(centerI), stateCount[2], stateCountTotal); - if (centerJ != null && (!pureBarcode || crossCheckDiagonal(Math.floor(centerI), Math.floor(centerJ), stateCount[2], stateCountTotal))) { - var estimatedModuleSize = stateCountTotal / 7; - var found = false; - for (var index = 0; index < possibleCenters.length; index++) { - var center = possibleCenters[index]; - // Look for about the same center and module size: - if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) { - possibleCenters.splice(index, 1, center.combineEstimate(centerI, centerJ, estimatedModuleSize)); - found = true; - break; - } - } - if (!found) { - // var point = new FinderPattern(centerJ.Value, centerI.Value, estimatedModuleSize); - var point = new FinderPattern(centerJ, centerI, estimatedModuleSize); - possibleCenters.push(point); - } - return true; - } - } - return false; - } - function findRowSkip() { - var max = possibleCenters.length; - if (max <= 1) { - return 0; - } - var firstConfirmedCenter = null; - possibleCenters.forEach(function (center) { - if (center.count >= CENTER_QUORUM) { - if (firstConfirmedCenter == null) { - firstConfirmedCenter = center; - } - else { - // We have two confirmed centers - // How far down can we skip before resuming looking for the next - // pattern? In the worst case, only the difference between the - // difference in the x / y coordinates of the two centers. - // This is the case where you find top left last. - hasSkipped = true; - //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" - return Math.floor(Math.abs(firstConfirmedCenter.x - center.x) - Math.abs(firstConfirmedCenter.y - center.y)) / 2; - } - } - }); - return 0; - } - function selectBestPatterns() { - var startSize = possibleCenters.length; - if (startSize < 3) { - // Couldn't find enough finder patterns - return null; - } - // Filter outlier possibilities whose module size is too different - if (startSize > 3) { - // But we can only afford to do so if we have at least 4 possibilities to choose from - var totalModuleSize = 0; - var square = 0; - possibleCenters.forEach(function (center) { - var size = center.estimatedModuleSize; - totalModuleSize += size; - square += size * size; - }); - var average = totalModuleSize / startSize; - var stdDev = Math.sqrt(square / startSize - average * average); - //possibleCenters.Sort(new FurthestFromAverageComparator(average)); - possibleCenters.sort(function (x, y) { - var dA = Math.abs(y.estimatedModuleSize - average); - var dB = Math.abs(x.estimatedModuleSize - average); - return dA < dB ? -1 : dA == dB ? 0 : 1; - }); - var limit = Math.max(0.2 * average, stdDev); - for (var i = 0; i < possibleCenters.length && possibleCenters.length > 3; i++) { - var pattern = possibleCenters[i]; - if (Math.abs(pattern.estimatedModuleSize - average) > limit) { - possibleCenters.splice(i, 1); - ///possibleCenters.RemoveAt(i); - i--; - } - } - } - if (possibleCenters.length > 3) { - // Throw away all but those first size candidate points we found. - var totalModuleSize = 0; - possibleCenters.forEach(function (possibleCenter) { - totalModuleSize += possibleCenter.estimatedModuleSize; - }); - var average = totalModuleSize / possibleCenters.length; - // possibleCenters.Sort(new CenterComparator(average)); - possibleCenters.sort(function (x, y) { - if (y.count === x.count) { - var dA = Math.abs(y.estimatedModuleSize - average); - var dB = Math.abs(x.estimatedModuleSize - average); - return dA < dB ? 1 : dA == dB ? 0 : -1; - } - return y.count - x.count; - }); - //possibleCenters.subList(3, possibleCenters.Count).clear(); - ///possibleCenters = possibleCenters.GetRange(0, 3); - possibleCenters = possibleCenters.slice(0, 3); - } - return [possibleCenters[0], possibleCenters[1], possibleCenters[2]]; - } - var pureBarcode = false; - var maxI = matrix.height; - var maxJ = matrix.width; - var iSkip = Math.floor((3 * maxI) / (4 * MAX_MODULES)); - if (iSkip < MIN_SKIP || false) { - iSkip = MIN_SKIP; - } - var done = false; - var stateCount = [0, 0, 0, 0, 0]; - for (var i = iSkip - 1; i < maxI && !done; i += iSkip) { - stateCount = [0, 0, 0, 0, 0]; - var currentState = 0; - for (var j = 0; j < maxJ; j++) { - if (get(j, i)) { - // Black pixel - if ((currentState & 1) === 1) { - currentState++; - } - stateCount[currentState]++; - } - else { - // White pixel - if ((currentState & 1) === 0) { - // Counting black pixels - if (currentState === 4) { - // A winner? - if (foundPatternCross(stateCount)) { - // Yes - var confirmed = handlePossibleCenter(stateCount, i, j, pureBarcode); - if (confirmed) { - // Start examining every other line. Checking each line turned out to be too - // expensive and didn't improve performance. - iSkip = 2; - if (hasSkipped) { - done = haveMultiplyConfirmedCenters(); - } - else { - var rowSkip = findRowSkip(); - if (rowSkip > stateCount[2]) { - // Skip rows between row of lower confirmed center - // and top of presumed third confirmed center - // but back up a bit to get a full chance of detecting - // it, entire width of center of finder pattern - // Skip by rowSkip, but back off by stateCount[2] (size of last center - // of pattern we saw) to be conservative, and also back off by iSkip which - // is about to be re-added - i += rowSkip - stateCount[2] - iSkip; - j = maxJ - 1; - } - } - } - else { - stateCount = [stateCount[2], stateCount[3], stateCount[4], 1, 0]; - currentState = 3; - continue; - } - // Clear state to start looking again - stateCount = [0, 0, 0, 0, 0]; - currentState = 0; - } - else { - stateCount = [stateCount[2], stateCount[3], stateCount[4], 1, 0]; - currentState = 3; - } - } - else { - // Should I really have copy/pasted this fuckery? - stateCount[++currentState]++; - } - } - else { - // Counting the white pixels - stateCount[currentState]++; - } - } - } - if (foundPatternCross(stateCount)) { - var confirmed = handlePossibleCenter(stateCount, i, maxJ, pureBarcode); - if (confirmed) { - iSkip = stateCount[0]; - if (hasSkipped) { - // Found a third one - done = haveMultiplyConfirmedCenters(); - } - } - } - } - var patternInfo = selectBestPatterns(); - if (!patternInfo) - return null; - return ReorderFinderPattern(patternInfo); - } - exports.locate = locate; + "use strict"; + var CENTER_QUORUM = 2; + var MIN_SKIP = 3; + var MAX_MODULES = 57; + var INTEGER_MATH_SHIFT = 8; + var FinderPattern = (function () { + function FinderPattern(x, y, estimatedModuleSize, count) { + this.x = x; + this.y = y; + this.estimatedModuleSize = estimatedModuleSize; + if (count == null) { + this.count = 1; + } + else { + this.count = count; + } + } + FinderPattern.prototype.aboutEquals = function (moduleSize, i, j) { + if (Math.abs(i - this.y) <= moduleSize && Math.abs(j - this.x) <= moduleSize) { + var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize); + return moduleSizeDiff <= 1.0 || moduleSizeDiff <= this.estimatedModuleSize; + } + return false; + }; + FinderPattern.prototype.combineEstimate = function (i, j, newModuleSize) { + var combinedCount = this.count + 1; + var combinedX = (this.count * this.x + j) / combinedCount; + var combinedY = (this.count * this.y + i) / combinedCount; + var combinedModuleSize = (this.count * this.estimatedModuleSize + newModuleSize) / combinedCount; + return new FinderPattern(combinedX, combinedY, combinedModuleSize, combinedCount); + }; + return FinderPattern; + }()); + function foundPatternCross(stateCount) { + var totalModuleSize = 0; + for (var i = 0; i < 5; i++) { + var count = stateCount[i]; + if (count === 0) + return false; + totalModuleSize += count; + } + if (totalModuleSize < 7) + return false; + var moduleSize = (totalModuleSize << INTEGER_MATH_SHIFT) / 7; + var maxVariance = moduleSize / 2; + // Allow less than 50% variance from 1-1-3-1-1 proportions + return Math.abs(moduleSize - (stateCount[0] << INTEGER_MATH_SHIFT)) < maxVariance && + Math.abs(moduleSize - (stateCount[1] << INTEGER_MATH_SHIFT)) < maxVariance && + Math.abs(3 * moduleSize - (stateCount[2] << INTEGER_MATH_SHIFT)) < 3 * maxVariance && + Math.abs(moduleSize - (stateCount[3] << INTEGER_MATH_SHIFT)) < maxVariance && + Math.abs(moduleSize - (stateCount[4] << INTEGER_MATH_SHIFT)) < maxVariance; + } + function centerFromEnd(stateCount, end) { + var result = (end - stateCount[4] - stateCount[3]) - stateCount[2] / 2; + // Fix this. + if (result !== result) { + return null; + } + return result; + } + function distance(pattern1, pattern2) { + var a = pattern1.x - pattern2.x; + var b = pattern1.y - pattern2.y; + return Math.sqrt(a * a + b * b); + } + function crossProductZ(pointA, pointB, pointC) { + var bX = pointB.x; + var bY = pointB.y; + return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX)); + } + function ReorderFinderPattern(patterns) { + // Find distances between pattern centers + var zeroOneDistance = distance(patterns[0], patterns[1]); + var oneTwoDistance = distance(patterns[1], patterns[2]); + var zeroTwoDistance = distance(patterns[0], patterns[2]); + var pointA, pointB, pointC; + // Assume one closest to other two is B; A and C will just be guesses at first + if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) { + pointB = patterns[0]; + pointA = patterns[1]; + pointC = patterns[2]; + } + else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) { + pointB = patterns[1]; + pointA = patterns[0]; + pointC = patterns[2]; + } + else { + pointB = patterns[2]; + pointA = patterns[0]; + pointC = patterns[1]; + } + // Use cross product to figure out whether A and C are correct or flipped. + // This asks whether BC x BA has a positive z component, which is the arrangement + // we want for A, B, C. If it's negative, then we've got it flipped around and + // should swap A and C. + if (crossProductZ(pointA, pointB, pointC) < 0) { + var temp = pointA; + pointA = pointC; + pointC = temp; + } + return { + bottomLeft: { x: pointA.x, y: pointA.y }, + topLeft: { x: pointB.x, y: pointB.y }, + topRight: { x: pointC.x, y: pointC.y } + }; + } + function locate(matrix) { + // Global state :( + var possibleCenters = []; + var hasSkipped = false; + function get(x, y) { + x = Math.floor(x); + y = Math.floor(y); + return matrix.get(x, y); + } + // Methods + function crossCheckDiagonal(startI, centerJ, maxCount, originalStateCountTotal) { + var maxI = matrix.height; + var maxJ = matrix.width; + var stateCount = [0, 0, 0, 0, 0]; + // Start counting up, left from center finding black center mass + var i = 0; + while (startI - i >= 0 && get(centerJ - i, startI - i)) { + stateCount[2]++; + i++; + } + if ((startI - i < 0) || (centerJ - i < 0)) { + return false; + } + // Continue up, left finding white space + while ((startI - i >= 0) && (centerJ - i >= 0) && !get(centerJ - i, startI - i) && stateCount[1] <= maxCount) { + stateCount[1]++; + i++; + } + // If already too many modules in this state or ran off the edge: + if ((startI - i < 0) || (centerJ - i < 0) || stateCount[1] > maxCount) { + return false; + } + // Continue up, left finding black border + while ((startI - i >= 0) && (centerJ - i >= 0) && get(centerJ - i, startI - i) && stateCount[0] <= maxCount) { + stateCount[0]++; + i++; + } + if (stateCount[0] > maxCount) { + return false; + } + // Now also count down, right from center + i = 1; + while ((startI + i < maxI) && (centerJ + i < maxJ) && get(centerJ + i, startI + i)) { + stateCount[2]++; + i++; + } + // Ran off the edge? + if ((startI + i >= maxI) || (centerJ + i >= maxJ)) { + return false; + } + while ((startI + i < maxI) && (centerJ + i < maxJ) && !get(centerJ + i, startI + i) && stateCount[3] < maxCount) { + stateCount[3]++; + i++; + } + if ((startI + i >= maxI) || (centerJ + i >= maxJ) || stateCount[3] >= maxCount) { + return false; + } + while ((startI + i < maxI) && (centerJ + i < maxJ) && get(centerJ + i, startI + i) && stateCount[4] < maxCount) { + stateCount[4]++; + i++; + } + if (stateCount[4] >= maxCount) { + return false; + } + // If we found a finder-pattern-like section, but its size is more than 100% different than + // the original, assume it's a false positive + var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; + return Math.abs(stateCountTotal - originalStateCountTotal) < 2 * originalStateCountTotal && + foundPatternCross(stateCount); + } + function crossCheckVertical(startI, centerJ, maxCount, originalStateCountTotal) { + var maxI = matrix.height; + var stateCount = [0, 0, 0, 0, 0]; + // Start counting up from center + var i = startI; + while (i >= 0 && get(centerJ, i)) { + stateCount[2]++; + i--; + } + if (i < 0) { + return null; + } + while (i >= 0 && !get(centerJ, i) && stateCount[1] <= maxCount) { + stateCount[1]++; + i--; + } + // If already too many modules in this state or ran off the edge: + if (i < 0 || stateCount[1] > maxCount) { + return null; + } + while (i >= 0 && get(centerJ, i) && stateCount[0] <= maxCount) { + stateCount[0]++; + i--; + } + if (stateCount[0] > maxCount) { + return null; + } + // Now also count down from center + i = startI + 1; + while (i < maxI && get(centerJ, i)) { + stateCount[2]++; + i++; + } + if (i == maxI) { + return null; + } + while (i < maxI && !get(centerJ, i) && stateCount[3] < maxCount) { + stateCount[3]++; + i++; + } + if (i == maxI || stateCount[3] >= maxCount) { + return null; + } + while (i < maxI && get(centerJ, i) && stateCount[4] < maxCount) { + stateCount[4]++; + i++; + } + if (stateCount[4] >= maxCount) { + return null; + } + // If we found a finder-pattern-like section, but its size is more than 40% different than + // the original, assume it's a false positive + var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; + if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) { + return null; + } + return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : null; + } + function haveMultiplyConfirmedCenters() { + var confirmedCount = 0; + var totalModuleSize = 0; + var max = possibleCenters.length; + possibleCenters.forEach(function (pattern) { + if (pattern.count >= CENTER_QUORUM) { + confirmedCount++; + totalModuleSize += pattern.estimatedModuleSize; + } + }); + if (confirmedCount < 3) { + return false; + } + // OK, we have at least 3 confirmed centers, but, it's possible that one is a "false positive" + // and that we need to keep looking. We detect this by asking if the estimated module sizes + // vary too much. We arbitrarily say that when the total deviation from average exceeds + // 5% of the total module size estimates, it's too much. + var average = totalModuleSize / max; + var totalDeviation = 0; + for (var i = 0; i < max; i++) { + var pattern = possibleCenters[i]; + totalDeviation += Math.abs(pattern.estimatedModuleSize - average); + } + return totalDeviation <= 0.05 * totalModuleSize; + } + function crossCheckHorizontal(startJ, centerI, maxCount, originalStateCountTotal) { + var maxJ = matrix.width; + var stateCount = [0, 0, 0, 0, 0]; + var j = startJ; + while (j >= 0 && get(j, centerI)) { + stateCount[2]++; + j--; + } + if (j < 0) { + return null; + } + while (j >= 0 && !get(j, centerI) && stateCount[1] <= maxCount) { + stateCount[1]++; + j--; + } + if (j < 0 || stateCount[1] > maxCount) { + return null; + } + while (j >= 0 && get(j, centerI) && stateCount[0] <= maxCount) { + stateCount[0]++; + j--; + } + if (stateCount[0] > maxCount) { + return null; + } + j = startJ + 1; + while (j < maxJ && get(j, centerI)) { + stateCount[2]++; + j++; + } + if (j == maxJ) { + return null; + } + while (j < maxJ && !get(j, centerI) && stateCount[3] < maxCount) { + stateCount[3]++; + j++; + } + if (j == maxJ || stateCount[3] >= maxCount) { + return null; + } + while (j < maxJ && get(j, centerI) && stateCount[4] < maxCount) { + stateCount[4]++; + j++; + } + if (stateCount[4] >= maxCount) { + return null; + } + // If we found a finder-pattern-like section, but its size is significantly different than + // the original, assume it's a false positive + var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; + if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) { + return null; + } + return foundPatternCross(stateCount) ? centerFromEnd(stateCount, j) : null; + } + function handlePossibleCenter(stateCount, i, j, pureBarcode) { + var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4]; + var centerJ = centerFromEnd(stateCount, j); + if (centerJ == null) + return false; + var centerI = crossCheckVertical(i, Math.floor(centerJ), stateCount[2], stateCountTotal); + if (centerI != null) { + // Re-cross check + centerJ = crossCheckHorizontal(Math.floor(centerJ), Math.floor(centerI), stateCount[2], stateCountTotal); + if (centerJ != null && (!pureBarcode || crossCheckDiagonal(Math.floor(centerI), Math.floor(centerJ), stateCount[2], stateCountTotal))) { + var estimatedModuleSize = stateCountTotal / 7; + var found = false; + for (var index = 0; index < possibleCenters.length; index++) { + var center = possibleCenters[index]; + // Look for about the same center and module size: + if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) { + possibleCenters.splice(index, 1, center.combineEstimate(centerI, centerJ, estimatedModuleSize)); + found = true; + break; + } + } + if (!found) { + // var point = new FinderPattern(centerJ.Value, centerI.Value, estimatedModuleSize); + var point = new FinderPattern(centerJ, centerI, estimatedModuleSize); + possibleCenters.push(point); + } + return true; + } + } + return false; + } + function findRowSkip() { + var max = possibleCenters.length; + if (max <= 1) { + return 0; + } + var firstConfirmedCenter = null; + possibleCenters.forEach(function (center) { + if (center.count >= CENTER_QUORUM) { + if (firstConfirmedCenter == null) { + firstConfirmedCenter = center; + } + else { + // We have two confirmed centers + // How far down can we skip before resuming looking for the next + // pattern? In the worst case, only the difference between the + // difference in the x / y coordinates of the two centers. + // This is the case where you find top left last. + hasSkipped = true; + //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" + return Math.floor(Math.abs(firstConfirmedCenter.x - center.x) - Math.abs(firstConfirmedCenter.y - center.y)) / 2; + } + } + }); + return 0; + } + function selectBestPatterns() { + var startSize = possibleCenters.length; + if (startSize < 3) { + // Couldn't find enough finder patterns + return null; + } + // Filter outlier possibilities whose module size is too different + if (startSize > 3) { + // But we can only afford to do so if we have at least 4 possibilities to choose from + var totalModuleSize = 0; + var square = 0; + possibleCenters.forEach(function (center) { + var size = center.estimatedModuleSize; + totalModuleSize += size; + square += size * size; + }); + var average = totalModuleSize / startSize; + var stdDev = Math.sqrt(square / startSize - average * average); + //possibleCenters.Sort(new FurthestFromAverageComparator(average)); + possibleCenters.sort(function (x, y) { + var dA = Math.abs(y.estimatedModuleSize - average); + var dB = Math.abs(x.estimatedModuleSize - average); + return dA < dB ? -1 : dA == dB ? 0 : 1; + }); + var limit = Math.max(0.2 * average, stdDev); + for (var i = 0; i < possibleCenters.length && possibleCenters.length > 3; i++) { + var pattern = possibleCenters[i]; + if (Math.abs(pattern.estimatedModuleSize - average) > limit) { + possibleCenters.splice(i, 1); + ///possibleCenters.RemoveAt(i); + i--; + } + } + } + if (possibleCenters.length > 3) { + // Throw away all but those first size candidate points we found. + var totalModuleSize = 0; + possibleCenters.forEach(function (possibleCenter) { + totalModuleSize += possibleCenter.estimatedModuleSize; + }); + var average = totalModuleSize / possibleCenters.length; + // possibleCenters.Sort(new CenterComparator(average)); + possibleCenters.sort(function (x, y) { + if (y.count === x.count) { + var dA = Math.abs(y.estimatedModuleSize - average); + var dB = Math.abs(x.estimatedModuleSize - average); + return dA < dB ? 1 : dA == dB ? 0 : -1; + } + return y.count - x.count; + }); + //possibleCenters.subList(3, possibleCenters.Count).clear(); + ///possibleCenters = possibleCenters.GetRange(0, 3); + possibleCenters = possibleCenters.slice(0, 3); + } + return [possibleCenters[0], possibleCenters[1], possibleCenters[2]]; + } + var pureBarcode = false; + var maxI = matrix.height; + var maxJ = matrix.width; + var iSkip = Math.floor((3 * maxI) / (4 * MAX_MODULES)); + if (iSkip < MIN_SKIP || false) { + iSkip = MIN_SKIP; + } + var done = false; + var stateCount = [0, 0, 0, 0, 0]; + for (var i = iSkip - 1; i < maxI && !done; i += iSkip) { + stateCount = [0, 0, 0, 0, 0]; + var currentState = 0; + for (var j = 0; j < maxJ; j++) { + if (get(j, i)) { + // Black pixel + if ((currentState & 1) === 1) { + currentState++; + } + stateCount[currentState]++; + } + else { + // White pixel + if ((currentState & 1) === 0) { + // Counting black pixels + if (currentState === 4) { + // A winner? + if (foundPatternCross(stateCount)) { + // Yes + var confirmed = handlePossibleCenter(stateCount, i, j, pureBarcode); + if (confirmed) { + // Start examining every other line. Checking each line turned out to be too + // expensive and didn't improve performance. + iSkip = 2; + if (hasSkipped) { + done = haveMultiplyConfirmedCenters(); + } + else { + var rowSkip = findRowSkip(); + if (rowSkip > stateCount[2]) { + // Skip rows between row of lower confirmed center + // and top of presumed third confirmed center + // but back up a bit to get a full chance of detecting + // it, entire width of center of finder pattern + // Skip by rowSkip, but back off by stateCount[2] (size of last center + // of pattern we saw) to be conservative, and also back off by iSkip which + // is about to be re-added + i += rowSkip - stateCount[2] - iSkip; + j = maxJ - 1; + } + } + } + else { + stateCount = [stateCount[2], stateCount[3], stateCount[4], 1, 0]; + currentState = 3; + continue; + } + // Clear state to start looking again + stateCount = [0, 0, 0, 0, 0]; + currentState = 0; + } + else { + stateCount = [stateCount[2], stateCount[3], stateCount[4], 1, 0]; + currentState = 3; + } + } + else { + // Should I really have copy/pasted this fuckery? + stateCount[++currentState]++; + } + } + else { + // Counting the white pixels + stateCount[currentState]++; + } + } + } + if (foundPatternCross(stateCount)) { + var confirmed = handlePossibleCenter(stateCount, i, maxJ, pureBarcode); + if (confirmed) { + iSkip = stateCount[0]; + if (hasSkipped) { + // Found a third one + done = haveMultiplyConfirmedCenters(); + } + } + } + } + var patternInfo = selectBestPatterns(); + if (!patternInfo) + return null; + return ReorderFinderPattern(patternInfo); + } + exports.locate = locate; /***/ }, /* 4 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - /// - var alignment_finder_1 = __webpack_require__(5); - var perspective_transform_1 = __webpack_require__(7); - var version_1 = __webpack_require__(8); - var bitmatrix_1 = __webpack_require__(2); - var helpers_1 = __webpack_require__(6); - function checkAndNudgePoints(width, height, points) { - // Check and nudge points from start until we see some that are OK: - var nudged = true; - for (var offset = 0; offset < points.length && nudged; offset += 2) { - var x = Math.floor(points[offset]); - var y = Math.floor(points[offset + 1]); - if (x < -1 || x > width || y < -1 || y > height) { - throw new Error(); - } - nudged = false; - if (x == -1) { - points[offset] = 0; - nudged = true; - } - else if (x == width) { - points[offset] = width - 1; - nudged = true; - } - if (y == -1) { - points[offset + 1] = 0; - nudged = true; - } - else if (y == height) { - points[offset + 1] = height - 1; - nudged = true; - } - } - // Check and nudge points from end: - nudged = true; - for (var offset = points.length - 2; offset >= 0 && nudged; offset -= 2) { - var x = Math.floor(points[offset]); - var y = Math.floor(points[offset + 1]); - if (x < -1 || x > width || y < -1 || y > height) { - throw new Error(); - } - nudged = false; - if (x == -1) { - points[offset] = 0; - nudged = true; - } - else if (x == width) { - points[offset] = width - 1; - nudged = true; - } - if (y == -1) { - points[offset + 1] = 0; - nudged = true; - } - else if (y == height) { - points[offset + 1] = height - 1; - nudged = true; - } - } - return points; - } - function bitArrayFromImage(image, dimension, transform) { - if (dimension <= 0) { - return null; - } - var bits = bitmatrix_1.BitMatrix.createEmpty(dimension, dimension); - var points = new Array(dimension << 1); - for (var y = 0; y < dimension; y++) { - var max = points.length; - var iValue = y + 0.5; - for (var x = 0; x < max; x += 2) { - points[x] = (x >> 1) + 0.5; - points[x + 1] = iValue; - } - points = perspective_transform_1.transformPoints(transform, points); - // Quick check to see if points transformed to something inside the image; - // sufficient to check the endpoints - try { - var nudgedPoints = checkAndNudgePoints(image.width, image.height, points); - } - catch (e) { - return null; - } - // try { - for (var x = 0; x < max; x += 2) { - bits.set(x >> 1, y, image.get(Math.floor(nudgedPoints[x]), Math.floor(nudgedPoints[x + 1]))); - } - } - return bits; - } - function createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension) { - var dimMinusThree = dimension - 3.5; - var bottomRightX; - var bottomRightY; - var sourceBottomRightX; - var sourceBottomRightY; - if (alignmentPattern != null) { - bottomRightX = alignmentPattern.x; - bottomRightY = alignmentPattern.y; - sourceBottomRightX = sourceBottomRightY = dimMinusThree - 3; - } - else { - // Don't have an alignment pattern, just make up the bottom-right point - bottomRightX = (topRight.x - topLeft.x) + bottomLeft.x; - bottomRightY = (topRight.y - topLeft.y) + bottomLeft.y; - sourceBottomRightX = sourceBottomRightY = dimMinusThree; - } - return perspective_transform_1.quadrilateralToQuadrilateral(3.5, 3.5, dimMinusThree, 3.5, sourceBottomRightX, sourceBottomRightY, 3.5, dimMinusThree, topLeft.x, topLeft.y, topRight.x, topRight.y, bottomRightX, bottomRightY, bottomLeft.x, bottomLeft.y); - } - // Taken from 6th grade algebra - function distance(x1, y1, x2, y2) { - return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); - } - // Attempts to locate an alignment pattern in a limited region of the image, which is guessed to contain it. - // overallEstModuleSize - estimated module size so far - // estAlignmentX - coordinate of center of area probably containing alignment pattern - // estAlignmentY - y coordinate of above - // allowanceFactor - number of pixels in all directions to search from the center - function findAlignmentInRegion(overallEstModuleSize, estAlignmentX, estAlignmentY, allowanceFactor, image) { - estAlignmentX = Math.floor(estAlignmentX); - estAlignmentY = Math.floor(estAlignmentY); - // Look for an alignment pattern (3 modules in size) around where it should be - var allowance = Math.floor(allowanceFactor * overallEstModuleSize); - var alignmentAreaLeftX = Math.max(0, estAlignmentX - allowance); - var alignmentAreaRightX = Math.min(image.width, estAlignmentX + allowance); - if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) { - return null; - } - var alignmentAreaTopY = Math.max(0, estAlignmentY - allowance); - var alignmentAreaBottomY = Math.min(image.height - 1, estAlignmentY + allowance); - return alignment_finder_1.findAlignment(alignmentAreaLeftX, alignmentAreaTopY, alignmentAreaRightX - alignmentAreaLeftX, alignmentAreaBottomY - alignmentAreaTopY, overallEstModuleSize, image); - } - // Computes the dimension (number of modules on a size) of the QR Code based on the position of the finder - // patterns and estimated module size. - function computeDimension(topLeft, topRight, bottomLeft, moduleSize) { - var tltrCentersDimension = Math.round(distance(topLeft.x, topLeft.y, topRight.x, topRight.y) / moduleSize); - var tlblCentersDimension = Math.round(distance(topLeft.x, topLeft.y, bottomLeft.x, bottomLeft.y) / moduleSize); - var dimension = ((tltrCentersDimension + tlblCentersDimension) >> 1) + 7; - switch (dimension & 0x03) { - // mod 4 - case 0: - dimension++; - break; - // 1? do nothing - case 2: - dimension--; - break; - } - return dimension; - } - // Deduces version information purely from QR Code dimensions. - // http://chan.catiewayne.com/z/src/131044167276.jpg - function getProvisionalVersionForDimension(dimension) { - if (dimension % 4 != 1) { - return null; - } - var versionNumber = (dimension - 17) >> 2; - if (versionNumber < 1 || versionNumber > 40) { - return null; - } - return version_1.getVersionForNumber(versionNumber); - } - // This method traces a line from a point in the image, in the direction towards another point. - // It begins in a black region, and keeps going until it finds white, then black, then white again. - // It reports the distance from the start to this point.

- // - // This is used when figuring out how wide a finder pattern is, when the finder pattern - // may be skewed or rotated. - function sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY, image) { - fromX = Math.floor(fromX); - fromY = Math.floor(fromY); - toX = Math.floor(toX); - toY = Math.floor(toY); - // Mild variant of Bresenham's algorithm; - // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm - var steep = Math.abs(toY - fromY) > Math.abs(toX - fromX); - if (steep) { - var temp = fromX; - fromX = fromY; - fromY = temp; - temp = toX; - toX = toY; - toY = temp; - } - var dx = Math.abs(toX - fromX); - var dy = Math.abs(toY - fromY); - var error = -dx >> 1; - var xstep = fromX < toX ? 1 : -1; - var ystep = fromY < toY ? 1 : -1; - // In black pixels, looking for white, first or second time. - var state = 0; - // Loop up until x == toX, but not beyond - var xLimit = toX + xstep; - for (var x = fromX, y = fromY; x != xLimit; x += xstep) { - var realX = steep ? y : x; - var realY = steep ? x : y; - // Does current pixel mean we have moved white to black or vice versa? - // Scanning black in state 0,2 and white in state 1, so if we find the wrong - // color, advance to next state or end if we are in state 2 already - if ((state == 1) === image.get(realX, realY)) { - if (state == 2) { - return distance(x, y, fromX, fromY); - } - state++; - } - error += dy; - if (error > 0) { - if (y == toY) { - break; - } - y += ystep; - error -= dx; - } - } - // Found black-white-black; give the benefit of the doubt that the next pixel outside the image - // is "white" so this last point at (toX+xStep,toY) is the right ending. This is really a - // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this. - if (state == 2) { - return distance(toX + xstep, toY, fromX, fromY); - } - // else we didn't find even black-white-black; no estimate is really possible - return NaN; - } - // Computes the total width of a finder pattern by looking for a black-white-black run from the center - // in the direction of another point (another finder pattern center), and in the opposite direction too. - function sizeOfBlackWhiteBlackRunBothWays(fromX, fromY, toX, toY, image) { - var result = sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY, image); - // Now count other way -- don't run off image though of course - var scale = 1; - var otherToX = fromX - (toX - fromX); - if (otherToX < 0) { - scale = fromX / (fromX - otherToX); - otherToX = 0; - } - else if (otherToX >= image.width) { - scale = (image.width - 1 - fromX) / (otherToX - fromX); - otherToX = image.width - 1; - } - var otherToY = (fromY - (toY - fromY) * scale); - scale = 1; - if (otherToY < 0) { - scale = fromY / (fromY - otherToY); - otherToY = 0; - } - else if (otherToY >= image.height) { - scale = (image.height - 1 - fromY) / (otherToY - fromY); - otherToY = image.height - 1; - } - otherToX = (fromX + (otherToX - fromX) * scale); - result += sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY, image); - return result - 1; // -1 because we counted the middle pixel twice - } - function calculateModuleSizeOneWay(pattern, otherPattern, image) { - var moduleSizeEst1 = sizeOfBlackWhiteBlackRunBothWays(pattern.x, pattern.y, otherPattern.x, otherPattern.y, image); - var moduleSizeEst2 = sizeOfBlackWhiteBlackRunBothWays(otherPattern.x, otherPattern.y, pattern.x, pattern.y, image); - if (helpers_1.isNaN(moduleSizeEst1)) { - return moduleSizeEst2 / 7; - } - if (helpers_1.isNaN(moduleSizeEst2)) { - return moduleSizeEst1 / 7; - } - // Average them, and divide by 7 since we've counted the width of 3 black modules, - // and 1 white and 1 black module on either side. Ergo, divide sum by 14. - return (moduleSizeEst1 + moduleSizeEst2) / 14; - } - // Computes an average estimated module size based on estimated derived from the positions of the three finder patterns. - function calculateModuleSize(topLeft, topRight, bottomLeft, image) { - return (calculateModuleSizeOneWay(topLeft, topRight, image) + calculateModuleSizeOneWay(topLeft, bottomLeft, image)) / 2; - } - function extract(image, location) { - var moduleSize = calculateModuleSize(location.topLeft, location.topRight, location.bottomLeft, image); - if (moduleSize < 1) { - return null; - } - var dimension = computeDimension(location.topLeft, location.topRight, location.bottomLeft, moduleSize); - if (!dimension) { - return null; - } - var provisionalVersion = getProvisionalVersionForDimension(dimension); - if (provisionalVersion == null) { - return null; - } - var modulesBetweenFPCenters = provisionalVersion.getDimensionForVersion() - 7; - var alignmentPattern = null; - // Anything above version 1 has an alignment pattern - if (provisionalVersion.alignmentPatternCenters.length > 0) { - // Guess where a "bottom right" finder pattern would have been - var bottomRightX = location.topRight.x - location.topLeft.x + location.bottomLeft.x; - var bottomRightY = location.topRight.y - location.topLeft.y + location.bottomLeft.y; - // Estimate that alignment pattern is closer by 3 modules - // from "bottom right" to known top left location - var correctionToTopLeft = 1 - 3 / modulesBetweenFPCenters; - var estAlignmentX = location.topLeft.x + correctionToTopLeft * (bottomRightX - location.topLeft.x); - var estAlignmentY = location.topLeft.y + correctionToTopLeft * (bottomRightY - location.topLeft.y); - // Kind of arbitrary -- expand search radius before giving up - for (var i = 4; i <= 16; i <<= 1) { - alignmentPattern = findAlignmentInRegion(moduleSize, estAlignmentX, estAlignmentY, i, image); - if (!alignmentPattern) { - continue; - } - break; - } - } - var transform = createTransform(location.topLeft, location.topRight, location.bottomLeft, alignmentPattern, dimension); - return bitArrayFromImage(image, dimension, transform); - } - exports.extract = extract; + "use strict"; + /// + var alignment_finder_1 = __webpack_require__(5); + var perspective_transform_1 = __webpack_require__(7); + var version_1 = __webpack_require__(8); + var bitmatrix_1 = __webpack_require__(2); + var helpers_1 = __webpack_require__(6); + function checkAndNudgePoints(width, height, points) { + // Check and nudge points from start until we see some that are OK: + var nudged = true; + for (var offset = 0; offset < points.length && nudged; offset += 2) { + var x = Math.floor(points[offset]); + var y = Math.floor(points[offset + 1]); + if (x < -1 || x > width || y < -1 || y > height) { + throw new Error(); + } + nudged = false; + if (x == -1) { + points[offset] = 0; + nudged = true; + } + else if (x == width) { + points[offset] = width - 1; + nudged = true; + } + if (y == -1) { + points[offset + 1] = 0; + nudged = true; + } + else if (y == height) { + points[offset + 1] = height - 1; + nudged = true; + } + } + // Check and nudge points from end: + nudged = true; + for (var offset = points.length - 2; offset >= 0 && nudged; offset -= 2) { + var x = Math.floor(points[offset]); + var y = Math.floor(points[offset + 1]); + if (x < -1 || x > width || y < -1 || y > height) { + throw new Error(); + } + nudged = false; + if (x == -1) { + points[offset] = 0; + nudged = true; + } + else if (x == width) { + points[offset] = width - 1; + nudged = true; + } + if (y == -1) { + points[offset + 1] = 0; + nudged = true; + } + else if (y == height) { + points[offset + 1] = height - 1; + nudged = true; + } + } + return points; + } + function bitArrayFromImage(image, dimension, transform) { + if (dimension <= 0) { + return null; + } + var bits = bitmatrix_1.BitMatrix.createEmpty(dimension, dimension); + var points = new Array(dimension << 1); + for (var y = 0; y < dimension; y++) { + var max = points.length; + var iValue = y + 0.5; + for (var x = 0; x < max; x += 2) { + points[x] = (x >> 1) + 0.5; + points[x + 1] = iValue; + } + points = perspective_transform_1.transformPoints(transform, points); + // Quick check to see if points transformed to something inside the image; + // sufficient to check the endpoints + try { + var nudgedPoints = checkAndNudgePoints(image.width, image.height, points); + } + catch (e) { + return null; + } + // try { + for (var x = 0; x < max; x += 2) { + bits.set(x >> 1, y, image.get(Math.floor(nudgedPoints[x]), Math.floor(nudgedPoints[x + 1]))); + } + } + return bits; + } + function createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension) { + var dimMinusThree = dimension - 3.5; + var bottomRightX; + var bottomRightY; + var sourceBottomRightX; + var sourceBottomRightY; + if (alignmentPattern != null) { + bottomRightX = alignmentPattern.x; + bottomRightY = alignmentPattern.y; + sourceBottomRightX = sourceBottomRightY = dimMinusThree - 3; + } + else { + // Don't have an alignment pattern, just make up the bottom-right point + bottomRightX = (topRight.x - topLeft.x) + bottomLeft.x; + bottomRightY = (topRight.y - topLeft.y) + bottomLeft.y; + sourceBottomRightX = sourceBottomRightY = dimMinusThree; + } + return perspective_transform_1.quadrilateralToQuadrilateral(3.5, 3.5, dimMinusThree, 3.5, sourceBottomRightX, sourceBottomRightY, 3.5, dimMinusThree, topLeft.x, topLeft.y, topRight.x, topRight.y, bottomRightX, bottomRightY, bottomLeft.x, bottomLeft.y); + } + // Taken from 6th grade algebra + function distance(x1, y1, x2, y2) { + return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); + } + // Attempts to locate an alignment pattern in a limited region of the image, which is guessed to contain it. + // overallEstModuleSize - estimated module size so far + // estAlignmentX - coordinate of center of area probably containing alignment pattern + // estAlignmentY - y coordinate of above + // allowanceFactor - number of pixels in all directions to search from the center + function findAlignmentInRegion(overallEstModuleSize, estAlignmentX, estAlignmentY, allowanceFactor, image) { + estAlignmentX = Math.floor(estAlignmentX); + estAlignmentY = Math.floor(estAlignmentY); + // Look for an alignment pattern (3 modules in size) around where it should be + var allowance = Math.floor(allowanceFactor * overallEstModuleSize); + var alignmentAreaLeftX = Math.max(0, estAlignmentX - allowance); + var alignmentAreaRightX = Math.min(image.width, estAlignmentX + allowance); + if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) { + return null; + } + var alignmentAreaTopY = Math.max(0, estAlignmentY - allowance); + var alignmentAreaBottomY = Math.min(image.height - 1, estAlignmentY + allowance); + return alignment_finder_1.findAlignment(alignmentAreaLeftX, alignmentAreaTopY, alignmentAreaRightX - alignmentAreaLeftX, alignmentAreaBottomY - alignmentAreaTopY, overallEstModuleSize, image); + } + // Computes the dimension (number of modules on a size) of the QR Code based on the position of the finder + // patterns and estimated module size. + function computeDimension(topLeft, topRight, bottomLeft, moduleSize) { + var tltrCentersDimension = Math.round(distance(topLeft.x, topLeft.y, topRight.x, topRight.y) / moduleSize); + var tlblCentersDimension = Math.round(distance(topLeft.x, topLeft.y, bottomLeft.x, bottomLeft.y) / moduleSize); + var dimension = ((tltrCentersDimension + tlblCentersDimension) >> 1) + 7; + switch (dimension & 0x03) { + // mod 4 + case 0: + dimension++; + break; + // 1? do nothing + case 2: + dimension--; + break; + } + return dimension; + } + // Deduces version information purely from QR Code dimensions. + // http://chan.catiewayne.com/z/src/131044167276.jpg + function getProvisionalVersionForDimension(dimension) { + if (dimension % 4 != 1) { + return null; + } + var versionNumber = (dimension - 17) >> 2; + if (versionNumber < 1 || versionNumber > 40) { + return null; + } + return version_1.getVersionForNumber(versionNumber); + } + // This method traces a line from a point in the image, in the direction towards another point. + // It begins in a black region, and keeps going until it finds white, then black, then white again. + // It reports the distance from the start to this point.

+ // + // This is used when figuring out how wide a finder pattern is, when the finder pattern + // may be skewed or rotated. + function sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY, image) { + fromX = Math.floor(fromX); + fromY = Math.floor(fromY); + toX = Math.floor(toX); + toY = Math.floor(toY); + // Mild variant of Bresenham's algorithm; + // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm + var steep = Math.abs(toY - fromY) > Math.abs(toX - fromX); + if (steep) { + var temp = fromX; + fromX = fromY; + fromY = temp; + temp = toX; + toX = toY; + toY = temp; + } + var dx = Math.abs(toX - fromX); + var dy = Math.abs(toY - fromY); + var error = -dx >> 1; + var xstep = fromX < toX ? 1 : -1; + var ystep = fromY < toY ? 1 : -1; + // In black pixels, looking for white, first or second time. + var state = 0; + // Loop up until x == toX, but not beyond + var xLimit = toX + xstep; + for (var x = fromX, y = fromY; x != xLimit; x += xstep) { + var realX = steep ? y : x; + var realY = steep ? x : y; + // Does current pixel mean we have moved white to black or vice versa? + // Scanning black in state 0,2 and white in state 1, so if we find the wrong + // color, advance to next state or end if we are in state 2 already + if ((state == 1) === image.get(realX, realY)) { + if (state == 2) { + return distance(x, y, fromX, fromY); + } + state++; + } + error += dy; + if (error > 0) { + if (y == toY) { + break; + } + y += ystep; + error -= dx; + } + } + // Found black-white-black; give the benefit of the doubt that the next pixel outside the image + // is "white" so this last point at (toX+xStep,toY) is the right ending. This is really a + // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this. + if (state == 2) { + return distance(toX + xstep, toY, fromX, fromY); + } + // else we didn't find even black-white-black; no estimate is really possible + return NaN; + } + // Computes the total width of a finder pattern by looking for a black-white-black run from the center + // in the direction of another point (another finder pattern center), and in the opposite direction too. + function sizeOfBlackWhiteBlackRunBothWays(fromX, fromY, toX, toY, image) { + var result = sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY, image); + // Now count other way -- don't run off image though of course + var scale = 1; + var otherToX = fromX - (toX - fromX); + if (otherToX < 0) { + scale = fromX / (fromX - otherToX); + otherToX = 0; + } + else if (otherToX >= image.width) { + scale = (image.width - 1 - fromX) / (otherToX - fromX); + otherToX = image.width - 1; + } + var otherToY = (fromY - (toY - fromY) * scale); + scale = 1; + if (otherToY < 0) { + scale = fromY / (fromY - otherToY); + otherToY = 0; + } + else if (otherToY >= image.height) { + scale = (image.height - 1 - fromY) / (otherToY - fromY); + otherToY = image.height - 1; + } + otherToX = (fromX + (otherToX - fromX) * scale); + result += sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY, image); + return result - 1; // -1 because we counted the middle pixel twice + } + function calculateModuleSizeOneWay(pattern, otherPattern, image) { + var moduleSizeEst1 = sizeOfBlackWhiteBlackRunBothWays(pattern.x, pattern.y, otherPattern.x, otherPattern.y, image); + var moduleSizeEst2 = sizeOfBlackWhiteBlackRunBothWays(otherPattern.x, otherPattern.y, pattern.x, pattern.y, image); + if (helpers_1.isNaN(moduleSizeEst1)) { + return moduleSizeEst2 / 7; + } + if (helpers_1.isNaN(moduleSizeEst2)) { + return moduleSizeEst1 / 7; + } + // Average them, and divide by 7 since we've counted the width of 3 black modules, + // and 1 white and 1 black module on either side. Ergo, divide sum by 14. + return (moduleSizeEst1 + moduleSizeEst2) / 14; + } + // Computes an average estimated module size based on estimated derived from the positions of the three finder patterns. + function calculateModuleSize(topLeft, topRight, bottomLeft, image) { + return (calculateModuleSizeOneWay(topLeft, topRight, image) + calculateModuleSizeOneWay(topLeft, bottomLeft, image)) / 2; + } + function extract(image, location) { + var moduleSize = calculateModuleSize(location.topLeft, location.topRight, location.bottomLeft, image); + if (moduleSize < 1) { + return null; + } + var dimension = computeDimension(location.topLeft, location.topRight, location.bottomLeft, moduleSize); + if (!dimension) { + return null; + } + var provisionalVersion = getProvisionalVersionForDimension(dimension); + if (provisionalVersion == null) { + return null; + } + var modulesBetweenFPCenters = provisionalVersion.getDimensionForVersion() - 7; + var alignmentPattern = null; + // Anything above version 1 has an alignment pattern + if (provisionalVersion.alignmentPatternCenters.length > 0) { + // Guess where a "bottom right" finder pattern would have been + var bottomRightX = location.topRight.x - location.topLeft.x + location.bottomLeft.x; + var bottomRightY = location.topRight.y - location.topLeft.y + location.bottomLeft.y; + // Estimate that alignment pattern is closer by 3 modules + // from "bottom right" to known top left location + var correctionToTopLeft = 1 - 3 / modulesBetweenFPCenters; + var estAlignmentX = location.topLeft.x + correctionToTopLeft * (bottomRightX - location.topLeft.x); + var estAlignmentY = location.topLeft.y + correctionToTopLeft * (bottomRightY - location.topLeft.y); + // Kind of arbitrary -- expand search radius before giving up + for (var i = 4; i <= 16; i <<= 1) { + alignmentPattern = findAlignmentInRegion(moduleSize, estAlignmentX, estAlignmentY, i, image); + if (!alignmentPattern) { + continue; + } + break; + } + } + var transform = createTransform(location.topLeft, location.topRight, location.bottomLeft, alignmentPattern, dimension); + return bitArrayFromImage(image, dimension, transform); + } + exports.extract = extract; /***/ }, /* 5 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - var helpers_1 = __webpack_require__(6); - function aboutEquals(center, moduleSize, i, j) { - if (Math.abs(i - center.y) <= moduleSize && Math.abs(j - center.x) <= moduleSize) { - var moduleSizeDiff = Math.abs(moduleSize - center.estimatedModuleSize); - return moduleSizeDiff <= 1 || moduleSizeDiff <= center.estimatedModuleSize; - } - return false; - } - function combineEstimate(center, i, j, newModuleSize) { - var combinedX = (center.x + j) / 2; - var combinedY = (center.y + i) / 2; - var combinedModuleSize = (center.estimatedModuleSize + newModuleSize) / 2; - return { x: combinedX, y: combinedY, estimatedModuleSize: combinedModuleSize }; - } - // returns true if the proportions of the counts is close enough to the 1/1/1 ratios used by alignment - // patterns to be considered a match - function foundPatternCross(stateCount, moduleSize) { - var maxVariance = moduleSize / 2; - for (var i = 0; i < 3; i++) { - if (Math.abs(moduleSize - stateCount[i]) >= maxVariance) { - return false; - } - } - return true; - } - // Given a count of black/white/black pixels just seen and an end position, - // figures the location of the center of this black/white/black run. - function centerFromEnd(stateCount, end) { - var result = (end - stateCount[2]) - stateCount[1] / 2; - if (helpers_1.isNaN(result)) { - return null; - } - return result; - } - // After a horizontal scan finds a potential alignment pattern, this method - // "cross-checks" by scanning down vertically through the center of the possible - // alignment pattern to see if the same proportion is detected.

- // - // startI - row where an alignment pattern was detected - // centerJ - center of the section that appears to cross an alignment pattern - // maxCount - maximum reasonable number of modules that should be observed in any reading state, based - // on the results of the horizontal scan - // originalStateCountTotal - The original state count total - function crossCheckVertical(startI, centerJ, maxCount, originalStateCountTotal, moduleSize, image) { - var maxI = image.height; - var stateCount = [0, 0, 0]; - // Start counting up from center - var i = startI; - while (i >= 0 && image.get(centerJ, i) && stateCount[1] <= maxCount) { - stateCount[1]++; - i--; - } - // If already too many modules in this state or ran off the edge: - if (i < 0 || stateCount[1] > maxCount) { - return null; - } - while (i >= 0 && !image.get(centerJ, i) && stateCount[0] <= maxCount) { - stateCount[0]++; - i--; - } - if (stateCount[0] > maxCount) { - return null; - } - // Now also count down from center - i = startI + 1; - while (i < maxI && image.get(centerJ, i) && stateCount[1] <= maxCount) { - stateCount[1]++; - i++; - } - if (i == maxI || stateCount[1] > maxCount) { - return null; - } - while (i < maxI && !image.get(centerJ, i) && stateCount[2] <= maxCount) { - stateCount[2]++; - i++; - } - if (stateCount[2] > maxCount) { - return null; - } - var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2]; - if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) { - return null; - } - return foundPatternCross(stateCount, moduleSize) ? centerFromEnd(stateCount, i) : null; - } - function findAlignment(startX, startY, width, height, moduleSize, image) { - // Global State :( - var possibleCenters = []; - // This is called when a horizontal scan finds a possible alignment pattern. It will - // cross check with a vertical scan, and if successful, will see if this pattern had been - // found on a previous horizontal scan. If so, we consider it confirmed and conclude we have - // found the alignment pattern.

- // - // stateCount - reading state module counts from horizontal scan - // i - where alignment pattern may be found - // j - end of possible alignment pattern in row - function handlePossibleCenter(stateCount, i, j, moduleSize) { - var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2]; - var centerJ = centerFromEnd(stateCount, j); - if (centerJ == null) { - return null; - } - var centerI = crossCheckVertical(i, Math.floor(centerJ), 2 * stateCount[1], stateCountTotal, moduleSize, image); - if (centerI != null) { - var estimatedModuleSize = (stateCount[0] + stateCount[1] + stateCount[2]) / 3; - for (var i2 in possibleCenters) { - var center = possibleCenters[i2]; - // Look for about the same center and module size: - if (aboutEquals(center, estimatedModuleSize, centerI, centerJ)) { - return combineEstimate(center, centerI, centerJ, estimatedModuleSize); - } - } - // Hadn't found this before; save it - var point = { x: centerJ, y: centerI, estimatedModuleSize: estimatedModuleSize }; - possibleCenters.push(point); - } - return null; - } - var maxJ = startX + width; - var middleI = startY + (height >> 1); - // We are looking for black/white/black modules in 1:1:1 ratio; - // this tracks the number of black/white/black modules seen so far - var stateCount = [0, 0, 0]; // WTF - for (var iGen = 0; iGen < height; iGen++) { - // Search from middle outwards - var i = middleI + ((iGen & 0x01) == 0 ? ((iGen + 1) >> 1) : -((iGen + 1) >> 1)); - stateCount[0] = 0; - stateCount[1] = 0; - stateCount[2] = 0; - var j = startX; - // Burn off leading white pixels before anything else; if we start in the middle of - // a white run, it doesn't make sense to count its length, since we don't know if the - // white run continued to the left of the start point - while (j < maxJ && !image.get(j, i)) { - j++; - } - var currentState = 0; - while (j < maxJ) { - if (image.get(j, i)) { - // Black pixel - if (currentState == 1) { - // Counting black pixels - stateCount[currentState]++; - } - else { - // Counting white pixels - if (currentState == 2) { - // A winner? - if (foundPatternCross(stateCount, moduleSize)) { - // Yes - confirmed = handlePossibleCenter(stateCount, i, j, moduleSize); - if (confirmed != null) { - return confirmed; - } - } - stateCount[0] = stateCount[2]; - stateCount[1] = 1; - stateCount[2] = 0; - currentState = 1; - } - else { - stateCount[++currentState]++; - } - } - } - else { - // White pixel - if (currentState == 1) { - // Counting black pixels - currentState++; - } - stateCount[currentState]++; - } - j++; - } - if (foundPatternCross(stateCount, moduleSize)) { - var confirmed = handlePossibleCenter(stateCount, i, moduleSize, maxJ); - if (confirmed != null) { - return confirmed; - } - } - } - // Hmm, nothing we saw was observed and confirmed twice. If we had - // any guess at all, return it. - if (possibleCenters.length != 0) { - return possibleCenters[0]; - } - return null; - } - exports.findAlignment = findAlignment; + "use strict"; + var helpers_1 = __webpack_require__(6); + function aboutEquals(center, moduleSize, i, j) { + if (Math.abs(i - center.y) <= moduleSize && Math.abs(j - center.x) <= moduleSize) { + var moduleSizeDiff = Math.abs(moduleSize - center.estimatedModuleSize); + return moduleSizeDiff <= 1 || moduleSizeDiff <= center.estimatedModuleSize; + } + return false; + } + function combineEstimate(center, i, j, newModuleSize) { + var combinedX = (center.x + j) / 2; + var combinedY = (center.y + i) / 2; + var combinedModuleSize = (center.estimatedModuleSize + newModuleSize) / 2; + return { x: combinedX, y: combinedY, estimatedModuleSize: combinedModuleSize }; + } + // returns true if the proportions of the counts is close enough to the 1/1/1 ratios used by alignment + // patterns to be considered a match + function foundPatternCross(stateCount, moduleSize) { + var maxVariance = moduleSize / 2; + for (var i = 0; i < 3; i++) { + if (Math.abs(moduleSize - stateCount[i]) >= maxVariance) { + return false; + } + } + return true; + } + // Given a count of black/white/black pixels just seen and an end position, + // figures the location of the center of this black/white/black run. + function centerFromEnd(stateCount, end) { + var result = (end - stateCount[2]) - stateCount[1] / 2; + if (helpers_1.isNaN(result)) { + return null; + } + return result; + } + // After a horizontal scan finds a potential alignment pattern, this method + // "cross-checks" by scanning down vertically through the center of the possible + // alignment pattern to see if the same proportion is detected.

+ // + // startI - row where an alignment pattern was detected + // centerJ - center of the section that appears to cross an alignment pattern + // maxCount - maximum reasonable number of modules that should be observed in any reading state, based + // on the results of the horizontal scan + // originalStateCountTotal - The original state count total + function crossCheckVertical(startI, centerJ, maxCount, originalStateCountTotal, moduleSize, image) { + var maxI = image.height; + var stateCount = [0, 0, 0]; + // Start counting up from center + var i = startI; + while (i >= 0 && image.get(centerJ, i) && stateCount[1] <= maxCount) { + stateCount[1]++; + i--; + } + // If already too many modules in this state or ran off the edge: + if (i < 0 || stateCount[1] > maxCount) { + return null; + } + while (i >= 0 && !image.get(centerJ, i) && stateCount[0] <= maxCount) { + stateCount[0]++; + i--; + } + if (stateCount[0] > maxCount) { + return null; + } + // Now also count down from center + i = startI + 1; + while (i < maxI && image.get(centerJ, i) && stateCount[1] <= maxCount) { + stateCount[1]++; + i++; + } + if (i == maxI || stateCount[1] > maxCount) { + return null; + } + while (i < maxI && !image.get(centerJ, i) && stateCount[2] <= maxCount) { + stateCount[2]++; + i++; + } + if (stateCount[2] > maxCount) { + return null; + } + var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2]; + if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) { + return null; + } + return foundPatternCross(stateCount, moduleSize) ? centerFromEnd(stateCount, i) : null; + } + function findAlignment(startX, startY, width, height, moduleSize, image) { + // Global State :( + var possibleCenters = []; + // This is called when a horizontal scan finds a possible alignment pattern. It will + // cross check with a vertical scan, and if successful, will see if this pattern had been + // found on a previous horizontal scan. If so, we consider it confirmed and conclude we have + // found the alignment pattern.

+ // + // stateCount - reading state module counts from horizontal scan + // i - where alignment pattern may be found + // j - end of possible alignment pattern in row + function handlePossibleCenter(stateCount, i, j, moduleSize) { + var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2]; + var centerJ = centerFromEnd(stateCount, j); + if (centerJ == null) { + return null; + } + var centerI = crossCheckVertical(i, Math.floor(centerJ), 2 * stateCount[1], stateCountTotal, moduleSize, image); + if (centerI != null) { + var estimatedModuleSize = (stateCount[0] + stateCount[1] + stateCount[2]) / 3; + for (var i2 in possibleCenters) { + var center = possibleCenters[i2]; + // Look for about the same center and module size: + if (aboutEquals(center, estimatedModuleSize, centerI, centerJ)) { + return combineEstimate(center, centerI, centerJ, estimatedModuleSize); + } + } + // Hadn't found this before; save it + var point = { x: centerJ, y: centerI, estimatedModuleSize: estimatedModuleSize }; + possibleCenters.push(point); + } + return null; + } + var maxJ = startX + width; + var middleI = startY + (height >> 1); + // We are looking for black/white/black modules in 1:1:1 ratio; + // this tracks the number of black/white/black modules seen so far + var stateCount = [0, 0, 0]; // WTF + for (var iGen = 0; iGen < height; iGen++) { + // Search from middle outwards + var i = middleI + ((iGen & 0x01) == 0 ? ((iGen + 1) >> 1) : -((iGen + 1) >> 1)); + stateCount[0] = 0; + stateCount[1] = 0; + stateCount[2] = 0; + var j = startX; + // Burn off leading white pixels before anything else; if we start in the middle of + // a white run, it doesn't make sense to count its length, since we don't know if the + // white run continued to the left of the start point + while (j < maxJ && !image.get(j, i)) { + j++; + } + var currentState = 0; + while (j < maxJ) { + if (image.get(j, i)) { + // Black pixel + if (currentState == 1) { + // Counting black pixels + stateCount[currentState]++; + } + else { + // Counting white pixels + if (currentState == 2) { + // A winner? + if (foundPatternCross(stateCount, moduleSize)) { + // Yes + confirmed = handlePossibleCenter(stateCount, i, j, moduleSize); + if (confirmed != null) { + return confirmed; + } + } + stateCount[0] = stateCount[2]; + stateCount[1] = 1; + stateCount[2] = 0; + currentState = 1; + } + else { + stateCount[++currentState]++; + } + } + } + else { + // White pixel + if (currentState == 1) { + // Counting black pixels + currentState++; + } + stateCount[currentState]++; + } + j++; + } + if (foundPatternCross(stateCount, moduleSize)) { + var confirmed = handlePossibleCenter(stateCount, i, moduleSize, maxJ); + if (confirmed != null) { + return confirmed; + } + } + } + // Hmm, nothing we saw was observed and confirmed twice. If we had + // any guess at all, return it. + if (possibleCenters.length != 0) { + return possibleCenters[0]; + } + return null; + } + exports.findAlignment = findAlignment; /***/ }, /* 6 */ /***/ function(module, exports) { - "use strict"; - var BITS_SET_IN_HALF_BYTE = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4]; - function numBitsDiffering(a, b) { - a ^= b; // a now has a 1 bit exactly where its bit differs with b's - // Count bits set quickly with a series of lookups: - return BITS_SET_IN_HALF_BYTE[a & 0x0F] + - BITS_SET_IN_HALF_BYTE[((a >> 4) & 0x0F)] + - BITS_SET_IN_HALF_BYTE[((a >> 8) & 0x0F)] + - BITS_SET_IN_HALF_BYTE[((a >> 12) & 0x0F)] + - BITS_SET_IN_HALF_BYTE[((a >> 16) & 0x0F)] + - BITS_SET_IN_HALF_BYTE[((a >> 20) & 0x0F)] + - BITS_SET_IN_HALF_BYTE[((a >> 24) & 0x0F)] + - BITS_SET_IN_HALF_BYTE[((a >> 28) & 0x0F)]; - } - exports.numBitsDiffering = numBitsDiffering; - // Taken from underscore JS - function isNaN(obj) { - return Object.prototype.toString.call(obj) === '[object Number]' && obj !== +obj; - } - exports.isNaN = isNaN; + "use strict"; + var BITS_SET_IN_HALF_BYTE = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4]; + function numBitsDiffering(a, b) { + a ^= b; // a now has a 1 bit exactly where its bit differs with b's + // Count bits set quickly with a series of lookups: + return BITS_SET_IN_HALF_BYTE[a & 0x0F] + + BITS_SET_IN_HALF_BYTE[((a >> 4) & 0x0F)] + + BITS_SET_IN_HALF_BYTE[((a >> 8) & 0x0F)] + + BITS_SET_IN_HALF_BYTE[((a >> 12) & 0x0F)] + + BITS_SET_IN_HALF_BYTE[((a >> 16) & 0x0F)] + + BITS_SET_IN_HALF_BYTE[((a >> 20) & 0x0F)] + + BITS_SET_IN_HALF_BYTE[((a >> 24) & 0x0F)] + + BITS_SET_IN_HALF_BYTE[((a >> 28) & 0x0F)]; + } + exports.numBitsDiffering = numBitsDiffering; + // Taken from underscore JS + function isNaN(obj) { + return Object.prototype.toString.call(obj) === '[object Number]' && obj !== +obj; + } + exports.isNaN = isNaN; /***/ }, /* 7 */ /***/ function(module, exports) { - /// - "use strict"; - function squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3) { - var dx3 = x0 - x1 + x2 - x3; - var dy3 = y0 - y1 + y2 - y3; - if (dx3 == 0 && dy3 == 0) { - // Affine - return { - a11: x1 - x0, - a21: x2 - x1, - a31: x0, - a12: y1 - y0, - a22: y2 - y1, - a32: y0, - a13: 0, - a23: 0, - a33: 1 - }; - } - else { - var dx1 = x1 - x2; - var dx2 = x3 - x2; - var dy1 = y1 - y2; - var dy2 = y3 - y2; - var denominator = dx1 * dy2 - dx2 * dy1; - var a13 = (dx3 * dy2 - dx2 * dy3) / denominator; - var a23 = (dx1 * dy3 - dx3 * dy1) / denominator; - return { - a11: x1 - x0 + a13 * x1, - a21: x3 - x0 + a23 * x3, - a31: x0, - a12: y1 - y0 + a13 * y1, - a22: y3 - y0 + a23 * y3, - a32: y0, - a13: a13, - a23: a23, - a33: 1 - }; - } - } - function buildAdjoint(i) { - return { - a11: i.a22 * i.a33 - i.a23 * i.a32, - a21: i.a23 * i.a31 - i.a21 * i.a33, - a31: i.a21 * i.a32 - i.a22 * i.a31, - a12: i.a13 * i.a32 - i.a12 * i.a33, - a22: i.a11 * i.a33 - i.a13 * i.a31, - a32: i.a12 * i.a31 - i.a11 * i.a32, - a13: i.a12 * i.a23 - i.a13 * i.a22, - a23: i.a13 * i.a21 - i.a11 * i.a23, - a33: i.a11 * i.a22 - i.a12 * i.a21 - }; - } - function times(a, b) { - return { - a11: a.a11 * b.a11 + a.a21 * b.a12 + a.a31 * b.a13, - a21: a.a11 * b.a21 + a.a21 * b.a22 + a.a31 * b.a23, - a31: a.a11 * b.a31 + a.a21 * b.a32 + a.a31 * b.a33, - a12: a.a12 * b.a11 + a.a22 * b.a12 + a.a32 * b.a13, - a22: a.a12 * b.a21 + a.a22 * b.a22 + a.a32 * b.a23, - a32: a.a12 * b.a31 + a.a22 * b.a32 + a.a32 * b.a33, - a13: a.a13 * b.a11 + a.a23 * b.a12 + a.a33 * b.a13, - a23: a.a13 * b.a21 + a.a23 * b.a22 + a.a33 * b.a23, - a33: a.a13 * b.a31 + a.a23 * b.a32 + a.a33 * b.a33 - }; - } - function quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3) { - // Here, the adjoint serves as the inverse: - return buildAdjoint(squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3)); - } - function transformPoints(transform, points) { - var max = points.length; - var a11 = transform.a11; - var a12 = transform.a12; - var a13 = transform.a13; - var a21 = transform.a21; - var a22 = transform.a22; - var a23 = transform.a23; - var a31 = transform.a31; - var a32 = transform.a32; - var a33 = transform.a33; - for (var i = 0; i < max; i += 2) { - var x = points[i]; - var y = points[i + 1]; - var denominator = a13 * x + a23 * y + a33; - points[i] = (a11 * x + a21 * y + a31) / denominator; - points[i + 1] = (a12 * x + a22 * y + a32) / denominator; - } - return points; - } - exports.transformPoints = transformPoints; - function quadrilateralToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3, x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p) { - var qToS = quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3); - var sToQ = squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p); - return times(sToQ, qToS); - } - exports.quadrilateralToQuadrilateral = quadrilateralToQuadrilateral; + /// + "use strict"; + function squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3) { + var dx3 = x0 - x1 + x2 - x3; + var dy3 = y0 - y1 + y2 - y3; + if (dx3 == 0 && dy3 == 0) { + // Affine + return { + a11: x1 - x0, + a21: x2 - x1, + a31: x0, + a12: y1 - y0, + a22: y2 - y1, + a32: y0, + a13: 0, + a23: 0, + a33: 1 + }; + } + else { + var dx1 = x1 - x2; + var dx2 = x3 - x2; + var dy1 = y1 - y2; + var dy2 = y3 - y2; + var denominator = dx1 * dy2 - dx2 * dy1; + var a13 = (dx3 * dy2 - dx2 * dy3) / denominator; + var a23 = (dx1 * dy3 - dx3 * dy1) / denominator; + return { + a11: x1 - x0 + a13 * x1, + a21: x3 - x0 + a23 * x3, + a31: x0, + a12: y1 - y0 + a13 * y1, + a22: y3 - y0 + a23 * y3, + a32: y0, + a13: a13, + a23: a23, + a33: 1 + }; + } + } + function buildAdjoint(i) { + return { + a11: i.a22 * i.a33 - i.a23 * i.a32, + a21: i.a23 * i.a31 - i.a21 * i.a33, + a31: i.a21 * i.a32 - i.a22 * i.a31, + a12: i.a13 * i.a32 - i.a12 * i.a33, + a22: i.a11 * i.a33 - i.a13 * i.a31, + a32: i.a12 * i.a31 - i.a11 * i.a32, + a13: i.a12 * i.a23 - i.a13 * i.a22, + a23: i.a13 * i.a21 - i.a11 * i.a23, + a33: i.a11 * i.a22 - i.a12 * i.a21 + }; + } + function times(a, b) { + return { + a11: a.a11 * b.a11 + a.a21 * b.a12 + a.a31 * b.a13, + a21: a.a11 * b.a21 + a.a21 * b.a22 + a.a31 * b.a23, + a31: a.a11 * b.a31 + a.a21 * b.a32 + a.a31 * b.a33, + a12: a.a12 * b.a11 + a.a22 * b.a12 + a.a32 * b.a13, + a22: a.a12 * b.a21 + a.a22 * b.a22 + a.a32 * b.a23, + a32: a.a12 * b.a31 + a.a22 * b.a32 + a.a32 * b.a33, + a13: a.a13 * b.a11 + a.a23 * b.a12 + a.a33 * b.a13, + a23: a.a13 * b.a21 + a.a23 * b.a22 + a.a33 * b.a23, + a33: a.a13 * b.a31 + a.a23 * b.a32 + a.a33 * b.a33 + }; + } + function quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3) { + // Here, the adjoint serves as the inverse: + return buildAdjoint(squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3)); + } + function transformPoints(transform, points) { + var max = points.length; + var a11 = transform.a11; + var a12 = transform.a12; + var a13 = transform.a13; + var a21 = transform.a21; + var a22 = transform.a22; + var a23 = transform.a23; + var a31 = transform.a31; + var a32 = transform.a32; + var a33 = transform.a33; + for (var i = 0; i < max; i += 2) { + var x = points[i]; + var y = points[i + 1]; + var denominator = a13 * x + a23 * y + a33; + points[i] = (a11 * x + a21 * y + a31) / denominator; + points[i + 1] = (a12 * x + a22 * y + a32) / denominator; + } + return points; + } + exports.transformPoints = transformPoints; + function quadrilateralToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3, x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p) { + var qToS = quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3); + var sToQ = squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p); + return times(sToQ, qToS); + } + exports.quadrilateralToQuadrilateral = quadrilateralToQuadrilateral; /***/ }, /* 8 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - var helpers_1 = __webpack_require__(6); - var VERSION_DECODE_INFO = [ - 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, - 0x0C762, 0x0D847, 0x0E60D, 0x0F928, 0x10B78, - 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, - 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB, - 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250, - 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B, - 0x2542E, 0x26A64, 0x27541, 0x28C69, - ]; - var ECB = (function () { - function ECB(_count, _dataCodewords) { - this.count = _count; - this.dataCodewords = _dataCodewords; - } - return ECB; - }()); - var ECBlocks = (function () { - function ECBlocks(_ecCodewordsPerBlock) { - var _ecBlocks = []; - for (var _i = 1; _i < arguments.length; _i++) { - _ecBlocks[_i - 1] = arguments[_i]; - } - this.ecCodewordsPerBlock = _ecCodewordsPerBlock; - this.ecBlocks = _ecBlocks; - } - ECBlocks.prototype.getNumBlocks = function () { - return this.ecBlocks.reduce(function (a, b) { return (a + b.count); }, 0); - }; - ECBlocks.prototype.getTotalECCodewords = function () { - return this.ecCodewordsPerBlock * this.getNumBlocks(); - }; - return ECBlocks; - }()); - var Version = (function () { - function Version(_versionNumber, _alignmentPatternCenters) { - var _ecBlocks = []; - for (var _i = 2; _i < arguments.length; _i++) { - _ecBlocks[_i - 2] = arguments[_i]; - } - this.versionNumber = _versionNumber; - this.alignmentPatternCenters = _alignmentPatternCenters; - this.ecBlocks = _ecBlocks; - var total = 0; - var ecCodewords = this.ecBlocks[0].ecCodewordsPerBlock; - var ecbArray = this.ecBlocks[0].ecBlocks; - ecbArray.forEach(function (ecBlock) { - total += ecBlock.count * (ecBlock.dataCodewords + ecCodewords); - }); - this.totalCodewords = total; - } - Version.prototype.getDimensionForVersion = function () { - return 17 + 4 * this.versionNumber; - }; - Version.prototype.getECBlocksForLevel = function (ecLevel) { - return this.ecBlocks[ecLevel.ordinal]; - }; - Version.decodeVersionInformation = function (versionBits) { - var bestDifference = Infinity; - var bestVersion = 0; - for (var i = 0; i < VERSION_DECODE_INFO.length; i++) { - var targetVersion = VERSION_DECODE_INFO[i]; - // Do the version info bits match exactly? done. - if (targetVersion == versionBits) { - return getVersionForNumber(i + 7); - } - // Otherwise see if this is the closest to a real version info bit string - // we have seen so far - var bitsDifference = helpers_1.numBitsDiffering(versionBits, targetVersion); - if (bitsDifference < bestDifference) { - bestVersion = i + 7; - bestDifference = bitsDifference; - } - } - // We can tolerate up to 3 bits of error since no two version info codewords will - // differ in less than 8 bits. - if (bestDifference <= 3) { - return getVersionForNumber(bestVersion); - } - // If we didn't find a close enough match, fail - return null; - }; - return Version; - }()); - exports.Version = Version; - var VERSIONS = [ - new Version(1, [], new ECBlocks(7, new ECB(1, 19)), new ECBlocks(10, new ECB(1, 16)), new ECBlocks(13, new ECB(1, 13)), new ECBlocks(17, new ECB(1, 9))), - new Version(2, [6, 18], new ECBlocks(10, new ECB(1, 34)), new ECBlocks(16, new ECB(1, 28)), new ECBlocks(22, new ECB(1, 22)), new ECBlocks(28, new ECB(1, 16))), - new Version(3, [6, 22], new ECBlocks(15, new ECB(1, 55)), new ECBlocks(26, new ECB(1, 44)), new ECBlocks(18, new ECB(2, 17)), new ECBlocks(22, new ECB(2, 13))), - new Version(4, [6, 26], new ECBlocks(20, new ECB(1, 80)), new ECBlocks(18, new ECB(2, 32)), new ECBlocks(26, new ECB(2, 24)), new ECBlocks(16, new ECB(4, 9))), - new Version(5, [6, 30], new ECBlocks(26, new ECB(1, 108)), new ECBlocks(24, new ECB(2, 43)), new ECBlocks(18, new ECB(2, 15), new ECB(2, 16)), new ECBlocks(22, new ECB(2, 11), new ECB(2, 12))), - new Version(6, [6, 34], new ECBlocks(18, new ECB(2, 68)), new ECBlocks(16, new ECB(4, 27)), new ECBlocks(24, new ECB(4, 19)), new ECBlocks(28, new ECB(4, 15))), - new Version(7, [6, 22, 38], new ECBlocks(20, new ECB(2, 78)), new ECBlocks(18, new ECB(4, 31)), new ECBlocks(18, new ECB(2, 14), new ECB(4, 15)), new ECBlocks(26, new ECB(4, 13), new ECB(1, 14))), - new Version(8, [6, 24, 42], new ECBlocks(24, new ECB(2, 97)), new ECBlocks(22, new ECB(2, 38), new ECB(2, 39)), new ECBlocks(22, new ECB(4, 18), new ECB(2, 19)), new ECBlocks(26, new ECB(4, 14), new ECB(2, 15))), - new Version(9, [6, 26, 46], new ECBlocks(30, new ECB(2, 116)), new ECBlocks(22, new ECB(3, 36), new ECB(2, 37)), new ECBlocks(20, new ECB(4, 16), new ECB(4, 17)), new ECBlocks(24, new ECB(4, 12), new ECB(4, 13))), - new Version(10, [6, 28, 50], new ECBlocks(18, new ECB(2, 68), new ECB(2, 69)), new ECBlocks(26, new ECB(4, 43), new ECB(1, 44)), new ECBlocks(24, new ECB(6, 19), new ECB(2, 20)), new ECBlocks(28, new ECB(6, 15), new ECB(2, 16))), - new Version(11, [6, 30, 54], new ECBlocks(20, new ECB(4, 81)), new ECBlocks(30, new ECB(1, 50), new ECB(4, 51)), new ECBlocks(28, new ECB(4, 22), new ECB(4, 23)), new ECBlocks(24, new ECB(3, 12), new ECB(8, 13))), - new Version(12, [6, 32, 58], new ECBlocks(24, new ECB(2, 92), new ECB(2, 93)), new ECBlocks(22, new ECB(6, 36), new ECB(2, 37)), new ECBlocks(26, new ECB(4, 20), new ECB(6, 21)), new ECBlocks(28, new ECB(7, 14), new ECB(4, 15))), - new Version(13, [6, 34, 62], new ECBlocks(26, new ECB(4, 107)), new ECBlocks(22, new ECB(8, 37), new ECB(1, 38)), new ECBlocks(24, new ECB(8, 20), new ECB(4, 21)), new ECBlocks(22, new ECB(12, 11), new ECB(4, 12))), - new Version(14, [6, 26, 46, 66], new ECBlocks(30, new ECB(3, 115), new ECB(1, 116)), new ECBlocks(24, new ECB(4, 40), new ECB(5, 41)), new ECBlocks(20, new ECB(11, 16), new ECB(5, 17)), new ECBlocks(24, new ECB(11, 12), new ECB(5, 13))), - new Version(15, [6, 26, 48, 70], new ECBlocks(22, new ECB(5, 87), new ECB(1, 88)), new ECBlocks(24, new ECB(5, 41), new ECB(5, 42)), new ECBlocks(30, new ECB(5, 24), new ECB(7, 25)), new ECBlocks(24, new ECB(11, 12), new ECB(7, 13))), - new Version(16, [6, 26, 50, 74], new ECBlocks(24, new ECB(5, 98), new ECB(1, 99)), new ECBlocks(28, new ECB(7, 45), new ECB(3, 46)), new ECBlocks(24, new ECB(15, 19), new ECB(2, 20)), new ECBlocks(30, new ECB(3, 15), new ECB(13, 16))), - new Version(17, [6, 30, 54, 78], new ECBlocks(28, new ECB(1, 107), new ECB(5, 108)), new ECBlocks(28, new ECB(10, 46), new ECB(1, 47)), new ECBlocks(28, new ECB(1, 22), new ECB(15, 23)), new ECBlocks(28, new ECB(2, 14), new ECB(17, 15))), - new Version(18, [6, 30, 56, 82], new ECBlocks(30, new ECB(5, 120), new ECB(1, 121)), new ECBlocks(26, new ECB(9, 43), new ECB(4, 44)), new ECBlocks(28, new ECB(17, 22), new ECB(1, 23)), new ECBlocks(28, new ECB(2, 14), new ECB(19, 15))), - new Version(19, [6, 30, 58, 86], new ECBlocks(28, new ECB(3, 113), new ECB(4, 114)), new ECBlocks(26, new ECB(3, 44), new ECB(11, 45)), new ECBlocks(26, new ECB(17, 21), new ECB(4, 22)), new ECBlocks(26, new ECB(9, 13), new ECB(16, 14))), - new Version(20, [6, 34, 62, 90], new ECBlocks(28, new ECB(3, 107), new ECB(5, 108)), new ECBlocks(26, new ECB(3, 41), new ECB(13, 42)), new ECBlocks(30, new ECB(15, 24), new ECB(5, 25)), new ECBlocks(28, new ECB(15, 15), new ECB(10, 16))), - new Version(21, [6, 28, 50, 72, 94], new ECBlocks(28, new ECB(4, 116), new ECB(4, 117)), new ECBlocks(26, new ECB(17, 42)), new ECBlocks(28, new ECB(17, 22), new ECB(6, 23)), new ECBlocks(30, new ECB(19, 16), new ECB(6, 17))), - new Version(22, [6, 26, 50, 74, 98], new ECBlocks(28, new ECB(2, 111), new ECB(7, 112)), new ECBlocks(28, new ECB(17, 46)), new ECBlocks(30, new ECB(7, 24), new ECB(16, 25)), new ECBlocks(24, new ECB(34, 13))), - new Version(23, [6, 30, 54, 74, 102], new ECBlocks(30, new ECB(4, 121), new ECB(5, 122)), new ECBlocks(28, new ECB(4, 47), new ECB(14, 48)), new ECBlocks(30, new ECB(11, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(16, 15), new ECB(14, 16))), - new Version(24, [6, 28, 54, 80, 106], new ECBlocks(30, new ECB(6, 117), new ECB(4, 118)), new ECBlocks(28, new ECB(6, 45), new ECB(14, 46)), new ECBlocks(30, new ECB(11, 24), new ECB(16, 25)), new ECBlocks(30, new ECB(30, 16), new ECB(2, 17))), - new Version(25, [6, 32, 58, 84, 110], new ECBlocks(26, new ECB(8, 106), new ECB(4, 107)), new ECBlocks(28, new ECB(8, 47), new ECB(13, 48)), new ECBlocks(30, new ECB(7, 24), new ECB(22, 25)), new ECBlocks(30, new ECB(22, 15), new ECB(13, 16))), - new Version(26, [6, 30, 58, 86, 114], new ECBlocks(28, new ECB(10, 114), new ECB(2, 115)), new ECBlocks(28, new ECB(19, 46), new ECB(4, 47)), new ECBlocks(28, new ECB(28, 22), new ECB(6, 23)), new ECBlocks(30, new ECB(33, 16), new ECB(4, 17))), - new Version(27, [6, 34, 62, 90, 118], new ECBlocks(30, new ECB(8, 122), new ECB(4, 123)), new ECBlocks(28, new ECB(22, 45), new ECB(3, 46)), new ECBlocks(30, new ECB(8, 23), new ECB(26, 24)), new ECBlocks(30, new ECB(12, 15), new ECB(28, 16))), - new Version(28, [6, 26, 50, 74, 98, 122], new ECBlocks(30, new ECB(3, 117), new ECB(10, 118)), new ECBlocks(28, new ECB(3, 45), new ECB(23, 46)), new ECBlocks(30, new ECB(4, 24), new ECB(31, 25)), new ECBlocks(30, new ECB(11, 15), new ECB(31, 16))), - new Version(29, [6, 30, 54, 78, 102, 126], new ECBlocks(30, new ECB(7, 116), new ECB(7, 117)), new ECBlocks(28, new ECB(21, 45), new ECB(7, 46)), new ECBlocks(30, new ECB(1, 23), new ECB(37, 24)), new ECBlocks(30, new ECB(19, 15), new ECB(26, 16))), - new Version(30, [6, 26, 52, 78, 104, 130], new ECBlocks(30, new ECB(5, 115), new ECB(10, 116)), new ECBlocks(28, new ECB(19, 47), new ECB(10, 48)), new ECBlocks(30, new ECB(15, 24), new ECB(25, 25)), new ECBlocks(30, new ECB(23, 15), new ECB(25, 16))), - new Version(31, [6, 30, 56, 82, 108, 134], new ECBlocks(30, new ECB(13, 115), new ECB(3, 116)), new ECBlocks(28, new ECB(2, 46), new ECB(29, 47)), new ECBlocks(30, new ECB(42, 24), new ECB(1, 25)), new ECBlocks(30, new ECB(23, 15), new ECB(28, 16))), - new Version(32, [6, 34, 60, 86, 112, 138], new ECBlocks(30, new ECB(17, 115)), new ECBlocks(28, new ECB(10, 46), new ECB(23, 47)), new ECBlocks(30, new ECB(10, 24), new ECB(35, 25)), new ECBlocks(30, new ECB(19, 15), new ECB(35, 16))), - new Version(33, [6, 30, 58, 86, 114, 142], new ECBlocks(30, new ECB(17, 115), new ECB(1, 116)), new ECBlocks(28, new ECB(14, 46), new ECB(21, 47)), new ECBlocks(30, new ECB(29, 24), new ECB(19, 25)), new ECBlocks(30, new ECB(11, 15), new ECB(46, 16))), - new Version(34, [6, 34, 62, 90, 118, 146], new ECBlocks(30, new ECB(13, 115), new ECB(6, 116)), new ECBlocks(28, new ECB(14, 46), new ECB(23, 47)), new ECBlocks(30, new ECB(44, 24), new ECB(7, 25)), new ECBlocks(30, new ECB(59, 16), new ECB(1, 17))), - new Version(35, [6, 30, 54, 78, 102, 126, 150], new ECBlocks(30, new ECB(12, 121), new ECB(7, 122)), new ECBlocks(28, new ECB(12, 47), new ECB(26, 48)), new ECBlocks(30, new ECB(39, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(22, 15), new ECB(41, 16))), - new Version(36, [6, 24, 50, 76, 102, 128, 154], new ECBlocks(30, new ECB(6, 121), new ECB(14, 122)), new ECBlocks(28, new ECB(6, 47), new ECB(34, 48)), new ECBlocks(30, new ECB(46, 24), new ECB(10, 25)), new ECBlocks(30, new ECB(2, 15), new ECB(64, 16))), - new Version(37, [6, 28, 54, 80, 106, 132, 158], new ECBlocks(30, new ECB(17, 122), new ECB(4, 123)), new ECBlocks(28, new ECB(29, 46), new ECB(14, 47)), new ECBlocks(30, new ECB(49, 24), new ECB(10, 25)), new ECBlocks(30, new ECB(24, 15), new ECB(46, 16))), - new Version(38, [6, 32, 58, 84, 110, 136, 162], new ECBlocks(30, new ECB(4, 122), new ECB(18, 123)), new ECBlocks(28, new ECB(13, 46), new ECB(32, 47)), new ECBlocks(30, new ECB(48, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(42, 15), new ECB(32, 16))), - new Version(39, [6, 26, 54, 82, 110, 138, 166], new ECBlocks(30, new ECB(20, 117), new ECB(4, 118)), new ECBlocks(28, new ECB(40, 47), new ECB(7, 48)), new ECBlocks(30, new ECB(43, 24), new ECB(22, 25)), new ECBlocks(30, new ECB(10, 15), new ECB(67, 16))), - new Version(40, [6, 30, 58, 86, 114, 142, 170], new ECBlocks(30, new ECB(19, 118), new ECB(6, 119)), new ECBlocks(28, new ECB(18, 47), new ECB(31, 48)), new ECBlocks(30, new ECB(34, 24), new ECB(34, 25)), new ECBlocks(30, new ECB(20, 15), new ECB(61, 16))), - ]; - function getVersionForNumber(versionNumber) { - if (versionNumber < 1 || versionNumber > 40) { - throw new Error("Invalid version number " + versionNumber); - } - return VERSIONS[versionNumber - 1]; - } - exports.getVersionForNumber = getVersionForNumber; + "use strict"; + var helpers_1 = __webpack_require__(6); + var VERSION_DECODE_INFO = [ + 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, + 0x0C762, 0x0D847, 0x0E60D, 0x0F928, 0x10B78, + 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, + 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB, + 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250, + 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B, + 0x2542E, 0x26A64, 0x27541, 0x28C69, + ]; + var ECB = (function () { + function ECB(_count, _dataCodewords) { + this.count = _count; + this.dataCodewords = _dataCodewords; + } + return ECB; + }()); + var ECBlocks = (function () { + function ECBlocks(_ecCodewordsPerBlock) { + var _ecBlocks = []; + for (var _i = 1; _i < arguments.length; _i++) { + _ecBlocks[_i - 1] = arguments[_i]; + } + this.ecCodewordsPerBlock = _ecCodewordsPerBlock; + this.ecBlocks = _ecBlocks; + } + ECBlocks.prototype.getNumBlocks = function () { + return this.ecBlocks.reduce(function (a, b) { return (a + b.count); }, 0); + }; + ECBlocks.prototype.getTotalECCodewords = function () { + return this.ecCodewordsPerBlock * this.getNumBlocks(); + }; + return ECBlocks; + }()); + var Version = (function () { + function Version(_versionNumber, _alignmentPatternCenters) { + var _ecBlocks = []; + for (var _i = 2; _i < arguments.length; _i++) { + _ecBlocks[_i - 2] = arguments[_i]; + } + this.versionNumber = _versionNumber; + this.alignmentPatternCenters = _alignmentPatternCenters; + this.ecBlocks = _ecBlocks; + var total = 0; + var ecCodewords = this.ecBlocks[0].ecCodewordsPerBlock; + var ecbArray = this.ecBlocks[0].ecBlocks; + ecbArray.forEach(function (ecBlock) { + total += ecBlock.count * (ecBlock.dataCodewords + ecCodewords); + }); + this.totalCodewords = total; + } + Version.prototype.getDimensionForVersion = function () { + return 17 + 4 * this.versionNumber; + }; + Version.prototype.getECBlocksForLevel = function (ecLevel) { + return this.ecBlocks[ecLevel.ordinal]; + }; + Version.decodeVersionInformation = function (versionBits) { + var bestDifference = Infinity; + var bestVersion = 0; + for (var i = 0; i < VERSION_DECODE_INFO.length; i++) { + var targetVersion = VERSION_DECODE_INFO[i]; + // Do the version info bits match exactly? done. + if (targetVersion == versionBits) { + return getVersionForNumber(i + 7); + } + // Otherwise see if this is the closest to a real version info bit string + // we have seen so far + var bitsDifference = helpers_1.numBitsDiffering(versionBits, targetVersion); + if (bitsDifference < bestDifference) { + bestVersion = i + 7; + bestDifference = bitsDifference; + } + } + // We can tolerate up to 3 bits of error since no two version info codewords will + // differ in less than 8 bits. + if (bestDifference <= 3) { + return getVersionForNumber(bestVersion); + } + // If we didn't find a close enough match, fail + return null; + }; + return Version; + }()); + exports.Version = Version; + var VERSIONS = [ + new Version(1, [], new ECBlocks(7, new ECB(1, 19)), new ECBlocks(10, new ECB(1, 16)), new ECBlocks(13, new ECB(1, 13)), new ECBlocks(17, new ECB(1, 9))), + new Version(2, [6, 18], new ECBlocks(10, new ECB(1, 34)), new ECBlocks(16, new ECB(1, 28)), new ECBlocks(22, new ECB(1, 22)), new ECBlocks(28, new ECB(1, 16))), + new Version(3, [6, 22], new ECBlocks(15, new ECB(1, 55)), new ECBlocks(26, new ECB(1, 44)), new ECBlocks(18, new ECB(2, 17)), new ECBlocks(22, new ECB(2, 13))), + new Version(4, [6, 26], new ECBlocks(20, new ECB(1, 80)), new ECBlocks(18, new ECB(2, 32)), new ECBlocks(26, new ECB(2, 24)), new ECBlocks(16, new ECB(4, 9))), + new Version(5, [6, 30], new ECBlocks(26, new ECB(1, 108)), new ECBlocks(24, new ECB(2, 43)), new ECBlocks(18, new ECB(2, 15), new ECB(2, 16)), new ECBlocks(22, new ECB(2, 11), new ECB(2, 12))), + new Version(6, [6, 34], new ECBlocks(18, new ECB(2, 68)), new ECBlocks(16, new ECB(4, 27)), new ECBlocks(24, new ECB(4, 19)), new ECBlocks(28, new ECB(4, 15))), + new Version(7, [6, 22, 38], new ECBlocks(20, new ECB(2, 78)), new ECBlocks(18, new ECB(4, 31)), new ECBlocks(18, new ECB(2, 14), new ECB(4, 15)), new ECBlocks(26, new ECB(4, 13), new ECB(1, 14))), + new Version(8, [6, 24, 42], new ECBlocks(24, new ECB(2, 97)), new ECBlocks(22, new ECB(2, 38), new ECB(2, 39)), new ECBlocks(22, new ECB(4, 18), new ECB(2, 19)), new ECBlocks(26, new ECB(4, 14), new ECB(2, 15))), + new Version(9, [6, 26, 46], new ECBlocks(30, new ECB(2, 116)), new ECBlocks(22, new ECB(3, 36), new ECB(2, 37)), new ECBlocks(20, new ECB(4, 16), new ECB(4, 17)), new ECBlocks(24, new ECB(4, 12), new ECB(4, 13))), + new Version(10, [6, 28, 50], new ECBlocks(18, new ECB(2, 68), new ECB(2, 69)), new ECBlocks(26, new ECB(4, 43), new ECB(1, 44)), new ECBlocks(24, new ECB(6, 19), new ECB(2, 20)), new ECBlocks(28, new ECB(6, 15), new ECB(2, 16))), + new Version(11, [6, 30, 54], new ECBlocks(20, new ECB(4, 81)), new ECBlocks(30, new ECB(1, 50), new ECB(4, 51)), new ECBlocks(28, new ECB(4, 22), new ECB(4, 23)), new ECBlocks(24, new ECB(3, 12), new ECB(8, 13))), + new Version(12, [6, 32, 58], new ECBlocks(24, new ECB(2, 92), new ECB(2, 93)), new ECBlocks(22, new ECB(6, 36), new ECB(2, 37)), new ECBlocks(26, new ECB(4, 20), new ECB(6, 21)), new ECBlocks(28, new ECB(7, 14), new ECB(4, 15))), + new Version(13, [6, 34, 62], new ECBlocks(26, new ECB(4, 107)), new ECBlocks(22, new ECB(8, 37), new ECB(1, 38)), new ECBlocks(24, new ECB(8, 20), new ECB(4, 21)), new ECBlocks(22, new ECB(12, 11), new ECB(4, 12))), + new Version(14, [6, 26, 46, 66], new ECBlocks(30, new ECB(3, 115), new ECB(1, 116)), new ECBlocks(24, new ECB(4, 40), new ECB(5, 41)), new ECBlocks(20, new ECB(11, 16), new ECB(5, 17)), new ECBlocks(24, new ECB(11, 12), new ECB(5, 13))), + new Version(15, [6, 26, 48, 70], new ECBlocks(22, new ECB(5, 87), new ECB(1, 88)), new ECBlocks(24, new ECB(5, 41), new ECB(5, 42)), new ECBlocks(30, new ECB(5, 24), new ECB(7, 25)), new ECBlocks(24, new ECB(11, 12), new ECB(7, 13))), + new Version(16, [6, 26, 50, 74], new ECBlocks(24, new ECB(5, 98), new ECB(1, 99)), new ECBlocks(28, new ECB(7, 45), new ECB(3, 46)), new ECBlocks(24, new ECB(15, 19), new ECB(2, 20)), new ECBlocks(30, new ECB(3, 15), new ECB(13, 16))), + new Version(17, [6, 30, 54, 78], new ECBlocks(28, new ECB(1, 107), new ECB(5, 108)), new ECBlocks(28, new ECB(10, 46), new ECB(1, 47)), new ECBlocks(28, new ECB(1, 22), new ECB(15, 23)), new ECBlocks(28, new ECB(2, 14), new ECB(17, 15))), + new Version(18, [6, 30, 56, 82], new ECBlocks(30, new ECB(5, 120), new ECB(1, 121)), new ECBlocks(26, new ECB(9, 43), new ECB(4, 44)), new ECBlocks(28, new ECB(17, 22), new ECB(1, 23)), new ECBlocks(28, new ECB(2, 14), new ECB(19, 15))), + new Version(19, [6, 30, 58, 86], new ECBlocks(28, new ECB(3, 113), new ECB(4, 114)), new ECBlocks(26, new ECB(3, 44), new ECB(11, 45)), new ECBlocks(26, new ECB(17, 21), new ECB(4, 22)), new ECBlocks(26, new ECB(9, 13), new ECB(16, 14))), + new Version(20, [6, 34, 62, 90], new ECBlocks(28, new ECB(3, 107), new ECB(5, 108)), new ECBlocks(26, new ECB(3, 41), new ECB(13, 42)), new ECBlocks(30, new ECB(15, 24), new ECB(5, 25)), new ECBlocks(28, new ECB(15, 15), new ECB(10, 16))), + new Version(21, [6, 28, 50, 72, 94], new ECBlocks(28, new ECB(4, 116), new ECB(4, 117)), new ECBlocks(26, new ECB(17, 42)), new ECBlocks(28, new ECB(17, 22), new ECB(6, 23)), new ECBlocks(30, new ECB(19, 16), new ECB(6, 17))), + new Version(22, [6, 26, 50, 74, 98], new ECBlocks(28, new ECB(2, 111), new ECB(7, 112)), new ECBlocks(28, new ECB(17, 46)), new ECBlocks(30, new ECB(7, 24), new ECB(16, 25)), new ECBlocks(24, new ECB(34, 13))), + new Version(23, [6, 30, 54, 74, 102], new ECBlocks(30, new ECB(4, 121), new ECB(5, 122)), new ECBlocks(28, new ECB(4, 47), new ECB(14, 48)), new ECBlocks(30, new ECB(11, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(16, 15), new ECB(14, 16))), + new Version(24, [6, 28, 54, 80, 106], new ECBlocks(30, new ECB(6, 117), new ECB(4, 118)), new ECBlocks(28, new ECB(6, 45), new ECB(14, 46)), new ECBlocks(30, new ECB(11, 24), new ECB(16, 25)), new ECBlocks(30, new ECB(30, 16), new ECB(2, 17))), + new Version(25, [6, 32, 58, 84, 110], new ECBlocks(26, new ECB(8, 106), new ECB(4, 107)), new ECBlocks(28, new ECB(8, 47), new ECB(13, 48)), new ECBlocks(30, new ECB(7, 24), new ECB(22, 25)), new ECBlocks(30, new ECB(22, 15), new ECB(13, 16))), + new Version(26, [6, 30, 58, 86, 114], new ECBlocks(28, new ECB(10, 114), new ECB(2, 115)), new ECBlocks(28, new ECB(19, 46), new ECB(4, 47)), new ECBlocks(28, new ECB(28, 22), new ECB(6, 23)), new ECBlocks(30, new ECB(33, 16), new ECB(4, 17))), + new Version(27, [6, 34, 62, 90, 118], new ECBlocks(30, new ECB(8, 122), new ECB(4, 123)), new ECBlocks(28, new ECB(22, 45), new ECB(3, 46)), new ECBlocks(30, new ECB(8, 23), new ECB(26, 24)), new ECBlocks(30, new ECB(12, 15), new ECB(28, 16))), + new Version(28, [6, 26, 50, 74, 98, 122], new ECBlocks(30, new ECB(3, 117), new ECB(10, 118)), new ECBlocks(28, new ECB(3, 45), new ECB(23, 46)), new ECBlocks(30, new ECB(4, 24), new ECB(31, 25)), new ECBlocks(30, new ECB(11, 15), new ECB(31, 16))), + new Version(29, [6, 30, 54, 78, 102, 126], new ECBlocks(30, new ECB(7, 116), new ECB(7, 117)), new ECBlocks(28, new ECB(21, 45), new ECB(7, 46)), new ECBlocks(30, new ECB(1, 23), new ECB(37, 24)), new ECBlocks(30, new ECB(19, 15), new ECB(26, 16))), + new Version(30, [6, 26, 52, 78, 104, 130], new ECBlocks(30, new ECB(5, 115), new ECB(10, 116)), new ECBlocks(28, new ECB(19, 47), new ECB(10, 48)), new ECBlocks(30, new ECB(15, 24), new ECB(25, 25)), new ECBlocks(30, new ECB(23, 15), new ECB(25, 16))), + new Version(31, [6, 30, 56, 82, 108, 134], new ECBlocks(30, new ECB(13, 115), new ECB(3, 116)), new ECBlocks(28, new ECB(2, 46), new ECB(29, 47)), new ECBlocks(30, new ECB(42, 24), new ECB(1, 25)), new ECBlocks(30, new ECB(23, 15), new ECB(28, 16))), + new Version(32, [6, 34, 60, 86, 112, 138], new ECBlocks(30, new ECB(17, 115)), new ECBlocks(28, new ECB(10, 46), new ECB(23, 47)), new ECBlocks(30, new ECB(10, 24), new ECB(35, 25)), new ECBlocks(30, new ECB(19, 15), new ECB(35, 16))), + new Version(33, [6, 30, 58, 86, 114, 142], new ECBlocks(30, new ECB(17, 115), new ECB(1, 116)), new ECBlocks(28, new ECB(14, 46), new ECB(21, 47)), new ECBlocks(30, new ECB(29, 24), new ECB(19, 25)), new ECBlocks(30, new ECB(11, 15), new ECB(46, 16))), + new Version(34, [6, 34, 62, 90, 118, 146], new ECBlocks(30, new ECB(13, 115), new ECB(6, 116)), new ECBlocks(28, new ECB(14, 46), new ECB(23, 47)), new ECBlocks(30, new ECB(44, 24), new ECB(7, 25)), new ECBlocks(30, new ECB(59, 16), new ECB(1, 17))), + new Version(35, [6, 30, 54, 78, 102, 126, 150], new ECBlocks(30, new ECB(12, 121), new ECB(7, 122)), new ECBlocks(28, new ECB(12, 47), new ECB(26, 48)), new ECBlocks(30, new ECB(39, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(22, 15), new ECB(41, 16))), + new Version(36, [6, 24, 50, 76, 102, 128, 154], new ECBlocks(30, new ECB(6, 121), new ECB(14, 122)), new ECBlocks(28, new ECB(6, 47), new ECB(34, 48)), new ECBlocks(30, new ECB(46, 24), new ECB(10, 25)), new ECBlocks(30, new ECB(2, 15), new ECB(64, 16))), + new Version(37, [6, 28, 54, 80, 106, 132, 158], new ECBlocks(30, new ECB(17, 122), new ECB(4, 123)), new ECBlocks(28, new ECB(29, 46), new ECB(14, 47)), new ECBlocks(30, new ECB(49, 24), new ECB(10, 25)), new ECBlocks(30, new ECB(24, 15), new ECB(46, 16))), + new Version(38, [6, 32, 58, 84, 110, 136, 162], new ECBlocks(30, new ECB(4, 122), new ECB(18, 123)), new ECBlocks(28, new ECB(13, 46), new ECB(32, 47)), new ECBlocks(30, new ECB(48, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(42, 15), new ECB(32, 16))), + new Version(39, [6, 26, 54, 82, 110, 138, 166], new ECBlocks(30, new ECB(20, 117), new ECB(4, 118)), new ECBlocks(28, new ECB(40, 47), new ECB(7, 48)), new ECBlocks(30, new ECB(43, 24), new ECB(22, 25)), new ECBlocks(30, new ECB(10, 15), new ECB(67, 16))), + new Version(40, [6, 30, 58, 86, 114, 142, 170], new ECBlocks(30, new ECB(19, 118), new ECB(6, 119)), new ECBlocks(28, new ECB(18, 47), new ECB(31, 48)), new ECBlocks(30, new ECB(34, 24), new ECB(34, 25)), new ECBlocks(30, new ECB(20, 15), new ECB(61, 16))), + ]; + function getVersionForNumber(versionNumber) { + if (versionNumber < 1 || versionNumber > 40) { + throw new Error("Invalid version number " + versionNumber); + } + return VERSIONS[versionNumber - 1]; + } + exports.getVersionForNumber = getVersionForNumber; /***/ }, /* 9 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - var bitmatrix_1 = __webpack_require__(2); - var decodeqrdata_1 = __webpack_require__(10); - var helpers_1 = __webpack_require__(6); - var reedsolomon_1 = __webpack_require__(12); - var version_1 = __webpack_require__(8); - var FORMAT_INFO_MASK_QR = 0x5412; - var FORMAT_INFO_DECODE_LOOKUP = [ - [0x5412, 0x00], - [0x5125, 0x01], - [0x5E7C, 0x02], - [0x5B4B, 0x03], - [0x45F9, 0x04], - [0x40CE, 0x05], - [0x4F97, 0x06], - [0x4AA0, 0x07], - [0x77C4, 0x08], - [0x72F3, 0x09], - [0x7DAA, 0x0A], - [0x789D, 0x0B], - [0x662F, 0x0C], - [0x6318, 0x0D], - [0x6C41, 0x0E], - [0x6976, 0x0F], - [0x1689, 0x10], - [0x13BE, 0x11], - [0x1CE7, 0x12], - [0x19D0, 0x13], - [0x0762, 0x14], - [0x0255, 0x15], - [0x0D0C, 0x16], - [0x083B, 0x17], - [0x355F, 0x18], - [0x3068, 0x19], - [0x3F31, 0x1A], - [0x3A06, 0x1B], - [0x24B4, 0x1C], - [0x2183, 0x1D], - [0x2EDA, 0x1E], - [0x2BED, 0x1F], - ]; - var DATA_MASKS = [ - function (i, j) { return ((i + j) & 0x01) === 0; }, - function (i, j) { return (i & 0x01) === 0; }, - function (i, j) { return j % 3 == 0; }, - function (i, j) { return (i + j) % 3 === 0; }, - function (i, j) { return (((i >> 1) + (j / 3)) & 0x01) === 0; }, - function (i, j) { return ((i * j) & 0x01) + ((i * j) % 3) === 0; }, - function (i, j) { return ((((i * j) & 0x01) + ((i * j) % 3)) & 0x01) === 0; }, - function (i, j) { return ((((i + j) & 0x01) + ((i * j) % 3)) & 0x01) === 0; }, - ]; - var ERROR_CORRECTION_LEVELS = [ - { ordinal: 1, bits: 0x00, name: "M" }, - { ordinal: 0, bits: 0x01, name: "L" }, - { ordinal: 3, bits: 0x02, name: "H" }, - { ordinal: 2, bits: 0x03, name: "Q" }, - ]; - function buildFunctionPattern(version) { - var dimension = version.getDimensionForVersion(); - var emptyArray = new Array(dimension * dimension); - for (var i = 0; i < emptyArray.length; i++) { - emptyArray[i] = false; - } - var bitMatrix = new bitmatrix_1.BitMatrix(emptyArray, dimension); - ///BitMatrix bitMatrix = new BitMatrix(dimension); - // Top left finder pattern + separator + format - bitMatrix.setRegion(0, 0, 9, 9); - // Top right finder pattern + separator + format - bitMatrix.setRegion(dimension - 8, 0, 8, 9); - // Bottom left finder pattern + separator + format - bitMatrix.setRegion(0, dimension - 8, 9, 8); - // Alignment patterns - var max = version.alignmentPatternCenters.length; - for (var x = 0; x < max; x++) { - var i = version.alignmentPatternCenters[x] - 2; - for (var y = 0; y < max; y++) { - if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) { - // No alignment patterns near the three finder paterns - continue; - } - bitMatrix.setRegion(version.alignmentPatternCenters[y] - 2, i, 5, 5); - } - } - // Vertical timing pattern - bitMatrix.setRegion(6, 9, 1, dimension - 17); - // Horizontal timing pattern - bitMatrix.setRegion(9, 6, dimension - 17, 1); - if (version.versionNumber > 6) { - // Version info, top right - bitMatrix.setRegion(dimension - 11, 0, 3, 6); - // Version info, bottom left - bitMatrix.setRegion(0, dimension - 11, 6, 3); - } - return bitMatrix; - } - function readCodewords(matrix, version, formatInfo) { - // Get the data mask for the format used in this QR Code. This will exclude - // some bits from reading as we wind through the bit matrix. - var dataMask = DATA_MASKS[formatInfo.dataMask]; - var dimension = matrix.height; - var funcPattern = buildFunctionPattern(version); - var readingUp = true; - var result = []; - var resultOffset = 0; - var currentByte = 0; - var bitsRead = 0; - // Read columns in pairs, from right to left - for (var j = dimension - 1; j > 0; j -= 2) { - if (j == 6) { - // Skip whole column with vertical alignment pattern; - // saves time and makes the other code proceed more cleanly - j--; - } - // Read alternatingly from bottom to top then top to bottom - for (var count = 0; count < dimension; count++) { - var i = readingUp ? dimension - 1 - count : count; - for (var col = 0; col < 2; col++) { - // Ignore bits covered by the function pattern - if (!funcPattern.get(j - col, i)) { - // Read a bit - bitsRead++; - currentByte <<= 1; - if (matrix.get(j - col, i) !== dataMask(i, j - col)) { - currentByte |= 1; - } - // If we've made a whole byte, save it off - if (bitsRead == 8) { - result[resultOffset++] = currentByte & 0xFF; - bitsRead = 0; - currentByte = 0; - } - } - } - } - readingUp = !readingUp; // switch directions - } - if (resultOffset != version.totalCodewords) { - return null; - } - return result; - } - function readVersion(matrix) { - var dimension = matrix.height; - var provisionalVersion = (dimension - 17) >> 2; - if (provisionalVersion <= 6) { - return version_1.getVersionForNumber(provisionalVersion); - } - // Read top-right version info: 3 wide by 6 tall - var versionBits = 0; - var ijMin = dimension - 11; - for (var j = 5; j >= 0; j--) { - for (var i = dimension - 9; i >= ijMin; i--) { - versionBits = matrix.copyBit(i, j, versionBits); - } - } - var parsedVersion = version_1.Version.decodeVersionInformation(versionBits); - if (parsedVersion != null && parsedVersion.getDimensionForVersion() == dimension) { - return parsedVersion; - } - // Hmm, failed. Try bottom left: 6 wide by 3 tall - versionBits = 0; - for (var i = 5; i >= 0; i--) { - for (var j = dimension - 9; j >= ijMin; j--) { - versionBits = matrix.copyBit(i, j, versionBits); - } - } - parsedVersion = version_1.Version.decodeVersionInformation(versionBits); - if (parsedVersion != null && parsedVersion.getDimensionForVersion() == dimension) { - return parsedVersion; - } - return null; - } - function newFormatInformation(formatInfo) { - return { - errorCorrectionLevel: ERROR_CORRECTION_LEVELS[(formatInfo >> 3) & 0x03], - dataMask: formatInfo & 0x07 - }; - } - function doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2) { - // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing - var bestDifference = Infinity; - var bestFormatInfo = 0; - for (var i = 0; i < FORMAT_INFO_DECODE_LOOKUP.length; i++) { - var decodeInfo = FORMAT_INFO_DECODE_LOOKUP[i]; - var targetInfo = decodeInfo[0]; - if (targetInfo == maskedFormatInfo1 || targetInfo == maskedFormatInfo2) { - // Found an exact match - return newFormatInformation(decodeInfo[1]); - } - var bitsDifference = helpers_1.numBitsDiffering(maskedFormatInfo1, targetInfo); - if (bitsDifference < bestDifference) { - bestFormatInfo = decodeInfo[1]; - bestDifference = bitsDifference; - } - if (maskedFormatInfo1 != maskedFormatInfo2) { - // also try the other option - bitsDifference = helpers_1.numBitsDiffering(maskedFormatInfo2, targetInfo); - if (bitsDifference < bestDifference) { - bestFormatInfo = decodeInfo[1]; - bestDifference = bitsDifference; - } - } - } - // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits - // differing means we found a match - if (bestDifference <= 3) - return newFormatInformation(bestFormatInfo); - return null; - } - function decodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2) { - var formatInfo = doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2); - if (formatInfo) { - return formatInfo; - } - // Should return null, but, some QR codes apparently - // do not mask this info. Try again by actually masking the pattern - // first - return doDecodeFormatInformation(maskedFormatInfo1 ^ FORMAT_INFO_MASK_QR, maskedFormatInfo2 ^ FORMAT_INFO_MASK_QR); - } - function readFormatInformation(matrix) { - // Read top-left format info bits - var formatInfoBits1 = 0; - for (var i = 0; i < 6; i++) { - formatInfoBits1 = matrix.copyBit(i, 8, formatInfoBits1); - } - // .. and skip a bit in the timing pattern ... - formatInfoBits1 = matrix.copyBit(7, 8, formatInfoBits1); - formatInfoBits1 = matrix.copyBit(8, 8, formatInfoBits1); - formatInfoBits1 = matrix.copyBit(8, 7, formatInfoBits1); - // .. and skip a bit in the timing pattern ... - for (var j = 5; j >= 0; j--) { - formatInfoBits1 = matrix.copyBit(8, j, formatInfoBits1); - } - // Read the top-right/bottom-left pattern too - var dimension = matrix.height; - var formatInfoBits2 = 0; - var jMin = dimension - 7; - for (var j = dimension - 1; j >= jMin; j--) { - formatInfoBits2 = matrix.copyBit(8, j, formatInfoBits2); - } - for (var i = dimension - 8; i < dimension; i++) { - formatInfoBits2 = matrix.copyBit(i, 8, formatInfoBits2); - } - // parsedFormatInfo = FormatInformation.decodeFormatInformation(formatInfoBits1, formatInfoBits2); - var parsedFormatInfo = decodeFormatInformation(formatInfoBits1, formatInfoBits2); - if (parsedFormatInfo != null) { - return parsedFormatInfo; - } - return null; - } - function getDataBlocks(rawCodewords, version, ecLevel) { - if (rawCodewords.length != version.totalCodewords) { - throw new Error("Invalid number of codewords for version; got " + rawCodewords.length + " expected " + version.totalCodewords); - } - // Figure out the number and size of data blocks used by this version and - // error correction level - var ecBlocks = version.getECBlocksForLevel(ecLevel); - // First count the total number of data blocks - var totalBlocks = 0; - var ecBlockArray = ecBlocks.ecBlocks; - ecBlockArray.forEach(function (ecBlock) { - totalBlocks += ecBlock.count; - }); - // Now establish DataBlocks of the appropriate size and number of data codewords - var result = new Array(totalBlocks); - var numResultBlocks = 0; - ecBlockArray.forEach(function (ecBlock) { - for (var i = 0; i < ecBlock.count; i++) { - var numDataCodewords = ecBlock.dataCodewords; - var numBlockCodewords = ecBlocks.ecCodewordsPerBlock + numDataCodewords; - result[numResultBlocks++] = { numDataCodewords: numDataCodewords, codewords: new Array(numBlockCodewords) }; - } - }); - // All blocks have the same amount of data, except that the last n - // (where n may be 0) have 1 more byte. Figure out where these start. - var shorterBlocksTotalCodewords = result[0].codewords.length; - var longerBlocksStartAt = result.length - 1; - while (longerBlocksStartAt >= 0) { - var numCodewords = result[longerBlocksStartAt].codewords.length; - if (numCodewords == shorterBlocksTotalCodewords) { - break; - } - longerBlocksStartAt--; - } - longerBlocksStartAt++; - var shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.ecCodewordsPerBlock; - // The last elements of result may be 1 element longer; - // first fill out as many elements as all of them have - var rawCodewordsOffset = 0; - for (var i = 0; i < shorterBlocksNumDataCodewords; i++) { - for (var j = 0; j < numResultBlocks; j++) { - result[j].codewords[i] = rawCodewords[rawCodewordsOffset++]; - } - } - // Fill out the last data block in the longer ones - for (var j = longerBlocksStartAt; j < numResultBlocks; j++) { - result[j].codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++]; - } - // Now add in error correction blocks - var max = result[0].codewords.length; - for (var i = shorterBlocksNumDataCodewords; i < max; i++) { - for (var j = 0; j < numResultBlocks; j++) { - var iOffset = j < longerBlocksStartAt ? i : i + 1; - result[j].codewords[iOffset] = rawCodewords[rawCodewordsOffset++]; - } - } - return result; - } - function correctErrors(codewordBytes, numDataCodewords) { - var rsDecoder = new reedsolomon_1.ReedSolomonDecoder(); - var numCodewords = codewordBytes.length; - // First read into an array of ints - var codewordsInts = new Array(numCodewords); - for (var i = 0; i < numCodewords; i++) { - codewordsInts[i] = codewordBytes[i] & 0xFF; - } - var numECCodewords = codewordBytes.length - numDataCodewords; - if (!rsDecoder.decode(codewordsInts, numECCodewords)) - return false; - // Copy back into array of bytes -- only need to worry about the bytes that were data - // We don't care about errors in the error-correction codewords - for (var i = 0; i < numDataCodewords; i++) { - codewordBytes[i] = codewordsInts[i]; - } - return true; - } - function decodeMatrix(matrix) { - var version = readVersion(matrix); - if (!version) { - return null; - } - var formatInfo = readFormatInformation(matrix); - if (!formatInfo) { - return null; - } - var ecLevel = formatInfo.errorCorrectionLevel; - // Read codewords - var codewords = readCodewords(matrix, version, formatInfo); - if (!codewords) { - return null; - } - // Separate into data blocks - var dataBlocks = getDataBlocks(codewords, version, ecLevel); - // Count total number of data bytes - var totalBytes = 0; - dataBlocks.forEach(function (dataBlock) { - totalBytes += dataBlock.numDataCodewords; - }); - var resultBytes = new Array(totalBytes); - var resultOffset = 0; - // Error-correct and copy data blocks together into a stream of bytes - for (var _i = 0, dataBlocks_1 = dataBlocks; _i < dataBlocks_1.length; _i++) { - var dataBlock = dataBlocks_1[_i]; - var codewordBytes = dataBlock.codewords; - var numDataCodewords = dataBlock.numDataCodewords; - if (!correctErrors(codewordBytes, numDataCodewords)) - return null; - for (var i = 0; i < numDataCodewords; i++) { - resultBytes[resultOffset++] = codewordBytes[i]; - } - } - return decodeqrdata_1.decodeQRdata(resultBytes, version.versionNumber, ecLevel.name); - } - function decode(matrix) { - if (matrix == null) { - return null; - } - var result = decodeMatrix(matrix); - if (result) { - return result; - } - // Decoding didn't work, try mirroring the QR - matrix.mirror(); - return decodeMatrix(matrix); - } - exports.decode = decode; + "use strict"; + var bitmatrix_1 = __webpack_require__(2); + var decodeqrdata_1 = __webpack_require__(10); + var helpers_1 = __webpack_require__(6); + var reedsolomon_1 = __webpack_require__(12); + var version_1 = __webpack_require__(8); + var FORMAT_INFO_MASK_QR = 0x5412; + var FORMAT_INFO_DECODE_LOOKUP = [ + [0x5412, 0x00], + [0x5125, 0x01], + [0x5E7C, 0x02], + [0x5B4B, 0x03], + [0x45F9, 0x04], + [0x40CE, 0x05], + [0x4F97, 0x06], + [0x4AA0, 0x07], + [0x77C4, 0x08], + [0x72F3, 0x09], + [0x7DAA, 0x0A], + [0x789D, 0x0B], + [0x662F, 0x0C], + [0x6318, 0x0D], + [0x6C41, 0x0E], + [0x6976, 0x0F], + [0x1689, 0x10], + [0x13BE, 0x11], + [0x1CE7, 0x12], + [0x19D0, 0x13], + [0x0762, 0x14], + [0x0255, 0x15], + [0x0D0C, 0x16], + [0x083B, 0x17], + [0x355F, 0x18], + [0x3068, 0x19], + [0x3F31, 0x1A], + [0x3A06, 0x1B], + [0x24B4, 0x1C], + [0x2183, 0x1D], + [0x2EDA, 0x1E], + [0x2BED, 0x1F], + ]; + var DATA_MASKS = [ + function (i, j) { return ((i + j) & 0x01) === 0; }, + function (i, j) { return (i & 0x01) === 0; }, + function (i, j) { return j % 3 == 0; }, + function (i, j) { return (i + j) % 3 === 0; }, + function (i, j) { return (((i >> 1) + (j / 3)) & 0x01) === 0; }, + function (i, j) { return ((i * j) & 0x01) + ((i * j) % 3) === 0; }, + function (i, j) { return ((((i * j) & 0x01) + ((i * j) % 3)) & 0x01) === 0; }, + function (i, j) { return ((((i + j) & 0x01) + ((i * j) % 3)) & 0x01) === 0; }, + ]; + var ERROR_CORRECTION_LEVELS = [ + { ordinal: 1, bits: 0x00, name: "M" }, + { ordinal: 0, bits: 0x01, name: "L" }, + { ordinal: 3, bits: 0x02, name: "H" }, + { ordinal: 2, bits: 0x03, name: "Q" }, + ]; + function buildFunctionPattern(version) { + var dimension = version.getDimensionForVersion(); + var emptyArray = new Array(dimension * dimension); + for (var i = 0; i < emptyArray.length; i++) { + emptyArray[i] = false; + } + var bitMatrix = new bitmatrix_1.BitMatrix(emptyArray, dimension); + ///BitMatrix bitMatrix = new BitMatrix(dimension); + // Top left finder pattern + separator + format + bitMatrix.setRegion(0, 0, 9, 9); + // Top right finder pattern + separator + format + bitMatrix.setRegion(dimension - 8, 0, 8, 9); + // Bottom left finder pattern + separator + format + bitMatrix.setRegion(0, dimension - 8, 9, 8); + // Alignment patterns + var max = version.alignmentPatternCenters.length; + for (var x = 0; x < max; x++) { + var i = version.alignmentPatternCenters[x] - 2; + for (var y = 0; y < max; y++) { + if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) { + // No alignment patterns near the three finder paterns + continue; + } + bitMatrix.setRegion(version.alignmentPatternCenters[y] - 2, i, 5, 5); + } + } + // Vertical timing pattern + bitMatrix.setRegion(6, 9, 1, dimension - 17); + // Horizontal timing pattern + bitMatrix.setRegion(9, 6, dimension - 17, 1); + if (version.versionNumber > 6) { + // Version info, top right + bitMatrix.setRegion(dimension - 11, 0, 3, 6); + // Version info, bottom left + bitMatrix.setRegion(0, dimension - 11, 6, 3); + } + return bitMatrix; + } + function readCodewords(matrix, version, formatInfo) { + // Get the data mask for the format used in this QR Code. This will exclude + // some bits from reading as we wind through the bit matrix. + var dataMask = DATA_MASKS[formatInfo.dataMask]; + var dimension = matrix.height; + var funcPattern = buildFunctionPattern(version); + var readingUp = true; + var result = []; + var resultOffset = 0; + var currentByte = 0; + var bitsRead = 0; + // Read columns in pairs, from right to left + for (var j = dimension - 1; j > 0; j -= 2) { + if (j == 6) { + // Skip whole column with vertical alignment pattern; + // saves time and makes the other code proceed more cleanly + j--; + } + // Read alternatingly from bottom to top then top to bottom + for (var count = 0; count < dimension; count++) { + var i = readingUp ? dimension - 1 - count : count; + for (var col = 0; col < 2; col++) { + // Ignore bits covered by the function pattern + if (!funcPattern.get(j - col, i)) { + // Read a bit + bitsRead++; + currentByte <<= 1; + if (matrix.get(j - col, i) !== dataMask(i, j - col)) { + currentByte |= 1; + } + // If we've made a whole byte, save it off + if (bitsRead == 8) { + result[resultOffset++] = currentByte & 0xFF; + bitsRead = 0; + currentByte = 0; + } + } + } + } + readingUp = !readingUp; // switch directions + } + if (resultOffset != version.totalCodewords) { + return null; + } + return result; + } + function readVersion(matrix) { + var dimension = matrix.height; + var provisionalVersion = (dimension - 17) >> 2; + if (provisionalVersion <= 6) { + return version_1.getVersionForNumber(provisionalVersion); + } + // Read top-right version info: 3 wide by 6 tall + var versionBits = 0; + var ijMin = dimension - 11; + for (var j = 5; j >= 0; j--) { + for (var i = dimension - 9; i >= ijMin; i--) { + versionBits = matrix.copyBit(i, j, versionBits); + } + } + var parsedVersion = version_1.Version.decodeVersionInformation(versionBits); + if (parsedVersion != null && parsedVersion.getDimensionForVersion() == dimension) { + return parsedVersion; + } + // Hmm, failed. Try bottom left: 6 wide by 3 tall + versionBits = 0; + for (var i = 5; i >= 0; i--) { + for (var j = dimension - 9; j >= ijMin; j--) { + versionBits = matrix.copyBit(i, j, versionBits); + } + } + parsedVersion = version_1.Version.decodeVersionInformation(versionBits); + if (parsedVersion != null && parsedVersion.getDimensionForVersion() == dimension) { + return parsedVersion; + } + return null; + } + function newFormatInformation(formatInfo) { + return { + errorCorrectionLevel: ERROR_CORRECTION_LEVELS[(formatInfo >> 3) & 0x03], + dataMask: formatInfo & 0x07 + }; + } + function doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2) { + // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing + var bestDifference = Infinity; + var bestFormatInfo = 0; + for (var i = 0; i < FORMAT_INFO_DECODE_LOOKUP.length; i++) { + var decodeInfo = FORMAT_INFO_DECODE_LOOKUP[i]; + var targetInfo = decodeInfo[0]; + if (targetInfo == maskedFormatInfo1 || targetInfo == maskedFormatInfo2) { + // Found an exact match + return newFormatInformation(decodeInfo[1]); + } + var bitsDifference = helpers_1.numBitsDiffering(maskedFormatInfo1, targetInfo); + if (bitsDifference < bestDifference) { + bestFormatInfo = decodeInfo[1]; + bestDifference = bitsDifference; + } + if (maskedFormatInfo1 != maskedFormatInfo2) { + // also try the other option + bitsDifference = helpers_1.numBitsDiffering(maskedFormatInfo2, targetInfo); + if (bitsDifference < bestDifference) { + bestFormatInfo = decodeInfo[1]; + bestDifference = bitsDifference; + } + } + } + // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits + // differing means we found a match + if (bestDifference <= 3) + return newFormatInformation(bestFormatInfo); + return null; + } + function decodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2) { + var formatInfo = doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2); + if (formatInfo) { + return formatInfo; + } + // Should return null, but, some QR codes apparently + // do not mask this info. Try again by actually masking the pattern + // first + return doDecodeFormatInformation(maskedFormatInfo1 ^ FORMAT_INFO_MASK_QR, maskedFormatInfo2 ^ FORMAT_INFO_MASK_QR); + } + function readFormatInformation(matrix) { + // Read top-left format info bits + var formatInfoBits1 = 0; + for (var i = 0; i < 6; i++) { + formatInfoBits1 = matrix.copyBit(i, 8, formatInfoBits1); + } + // .. and skip a bit in the timing pattern ... + formatInfoBits1 = matrix.copyBit(7, 8, formatInfoBits1); + formatInfoBits1 = matrix.copyBit(8, 8, formatInfoBits1); + formatInfoBits1 = matrix.copyBit(8, 7, formatInfoBits1); + // .. and skip a bit in the timing pattern ... + for (var j = 5; j >= 0; j--) { + formatInfoBits1 = matrix.copyBit(8, j, formatInfoBits1); + } + // Read the top-right/bottom-left pattern too + var dimension = matrix.height; + var formatInfoBits2 = 0; + var jMin = dimension - 7; + for (var j = dimension - 1; j >= jMin; j--) { + formatInfoBits2 = matrix.copyBit(8, j, formatInfoBits2); + } + for (var i = dimension - 8; i < dimension; i++) { + formatInfoBits2 = matrix.copyBit(i, 8, formatInfoBits2); + } + // parsedFormatInfo = FormatInformation.decodeFormatInformation(formatInfoBits1, formatInfoBits2); + var parsedFormatInfo = decodeFormatInformation(formatInfoBits1, formatInfoBits2); + if (parsedFormatInfo != null) { + return parsedFormatInfo; + } + return null; + } + function getDataBlocks(rawCodewords, version, ecLevel) { + if (rawCodewords.length != version.totalCodewords) { + throw new Error("Invalid number of codewords for version; got " + rawCodewords.length + " expected " + version.totalCodewords); + } + // Figure out the number and size of data blocks used by this version and + // error correction level + var ecBlocks = version.getECBlocksForLevel(ecLevel); + // First count the total number of data blocks + var totalBlocks = 0; + var ecBlockArray = ecBlocks.ecBlocks; + ecBlockArray.forEach(function (ecBlock) { + totalBlocks += ecBlock.count; + }); + // Now establish DataBlocks of the appropriate size and number of data codewords + var result = new Array(totalBlocks); + var numResultBlocks = 0; + ecBlockArray.forEach(function (ecBlock) { + for (var i = 0; i < ecBlock.count; i++) { + var numDataCodewords = ecBlock.dataCodewords; + var numBlockCodewords = ecBlocks.ecCodewordsPerBlock + numDataCodewords; + result[numResultBlocks++] = { numDataCodewords: numDataCodewords, codewords: new Array(numBlockCodewords) }; + } + }); + // All blocks have the same amount of data, except that the last n + // (where n may be 0) have 1 more byte. Figure out where these start. + var shorterBlocksTotalCodewords = result[0].codewords.length; + var longerBlocksStartAt = result.length - 1; + while (longerBlocksStartAt >= 0) { + var numCodewords = result[longerBlocksStartAt].codewords.length; + if (numCodewords == shorterBlocksTotalCodewords) { + break; + } + longerBlocksStartAt--; + } + longerBlocksStartAt++; + var shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.ecCodewordsPerBlock; + // The last elements of result may be 1 element longer; + // first fill out as many elements as all of them have + var rawCodewordsOffset = 0; + for (var i = 0; i < shorterBlocksNumDataCodewords; i++) { + for (var j = 0; j < numResultBlocks; j++) { + result[j].codewords[i] = rawCodewords[rawCodewordsOffset++]; + } + } + // Fill out the last data block in the longer ones + for (var j = longerBlocksStartAt; j < numResultBlocks; j++) { + result[j].codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++]; + } + // Now add in error correction blocks + var max = result[0].codewords.length; + for (var i = shorterBlocksNumDataCodewords; i < max; i++) { + for (var j = 0; j < numResultBlocks; j++) { + var iOffset = j < longerBlocksStartAt ? i : i + 1; + result[j].codewords[iOffset] = rawCodewords[rawCodewordsOffset++]; + } + } + return result; + } + function correctErrors(codewordBytes, numDataCodewords) { + var rsDecoder = new reedsolomon_1.ReedSolomonDecoder(); + var numCodewords = codewordBytes.length; + // First read into an array of ints + var codewordsInts = new Array(numCodewords); + for (var i = 0; i < numCodewords; i++) { + codewordsInts[i] = codewordBytes[i] & 0xFF; + } + var numECCodewords = codewordBytes.length - numDataCodewords; + if (!rsDecoder.decode(codewordsInts, numECCodewords)) + return false; + // Copy back into array of bytes -- only need to worry about the bytes that were data + // We don't care about errors in the error-correction codewords + for (var i = 0; i < numDataCodewords; i++) { + codewordBytes[i] = codewordsInts[i]; + } + return true; + } + function decodeMatrix(matrix) { + var version = readVersion(matrix); + if (!version) { + return null; + } + var formatInfo = readFormatInformation(matrix); + if (!formatInfo) { + return null; + } + var ecLevel = formatInfo.errorCorrectionLevel; + // Read codewords + var codewords = readCodewords(matrix, version, formatInfo); + if (!codewords) { + return null; + } + // Separate into data blocks + var dataBlocks = getDataBlocks(codewords, version, ecLevel); + // Count total number of data bytes + var totalBytes = 0; + dataBlocks.forEach(function (dataBlock) { + totalBytes += dataBlock.numDataCodewords; + }); + var resultBytes = new Array(totalBytes); + var resultOffset = 0; + // Error-correct and copy data blocks together into a stream of bytes + for (var _i = 0, dataBlocks_1 = dataBlocks; _i < dataBlocks_1.length; _i++) { + var dataBlock = dataBlocks_1[_i]; + var codewordBytes = dataBlock.codewords; + var numDataCodewords = dataBlock.numDataCodewords; + if (!correctErrors(codewordBytes, numDataCodewords)) + return null; + for (var i = 0; i < numDataCodewords; i++) { + resultBytes[resultOffset++] = codewordBytes[i]; + } + } + return decodeqrdata_1.decodeQRdata(resultBytes, version.versionNumber, ecLevel.name); + } + function decode(matrix) { + if (matrix == null) { + return null; + } + var result = decodeMatrix(matrix); + if (result) { + return result; + } + // Decoding didn't work, try mirroring the QR + matrix.mirror(); + return decodeMatrix(matrix); + } + exports.decode = decode; /***/ }, /* 10 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - var bitstream_1 = __webpack_require__(11); - function toAlphaNumericByte(value) { - var ALPHANUMERIC_CHARS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', - 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', - 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', - ' ', '$', '%', '*', '+', '-', '.', '/', ':']; - if (value >= ALPHANUMERIC_CHARS.length) { - throw new Error("Could not decode alphanumeric char"); - } - return ALPHANUMERIC_CHARS[value].charCodeAt(0); - } - var Mode = (function () { - function Mode(characterCountBitsForVersions, bits) { - this.characterCountBitsForVersions = characterCountBitsForVersions; - this.bits = bits; - } - Mode.prototype.getCharacterCountBits = function (version) { - if (this.characterCountBitsForVersions == null) { - throw new Error("Character count doesn't apply to this mode"); - } - var offset; - if (version <= 9) { - offset = 0; - } - else if (version <= 26) { - offset = 1; - } - else { - offset = 2; - } - return this.characterCountBitsForVersions[offset]; - }; - return Mode; - }()); - var TERMINATOR_MODE = new Mode([0, 0, 0], 0x00); // Not really a mod... - var NUMERIC_MODE = new Mode([10, 12, 14], 0x01); - var ALPHANUMERIC_MODE = new Mode([9, 11, 13], 0x02); - var STRUCTURED_APPEND_MODE = new Mode([0, 0, 0], 0x03); // Not supported - var BYTE_MODE = new Mode([8, 16, 16], 0x04); - var ECI_MODE = new Mode(null, 0x07); // character counts don't apply - var KANJI_MODE = new Mode([8, 10, 12], 0x08); - var FNC1_FIRST_POSITION_MODE = new Mode(null, 0x05); - var FNC1_SECOND_POSITION_MODE = new Mode(null, 0x09); - var HANZI_MODE = new Mode([8, 10, 12], 0x0D); - function modeForBits(bits) { - switch (bits) { - case 0x0: - return TERMINATOR_MODE; - case 0x1: - return NUMERIC_MODE; - case 0x2: - return ALPHANUMERIC_MODE; - case 0x3: - return STRUCTURED_APPEND_MODE; - case 0x4: - return BYTE_MODE; - case 0x5: - return FNC1_FIRST_POSITION_MODE; - case 0x7: - return ECI_MODE; - case 0x8: - return KANJI_MODE; - case 0x9: - return FNC1_SECOND_POSITION_MODE; - case 0xD: - // 0xD is defined in GBT 18284-2000, may not be supported in foreign country - return HANZI_MODE; - default: - throw new Error("Couldn't decode mode from byte array"); - } - } - function parseECIValue(bits) { - var firstByte = bits.readBits(8); - if ((firstByte & 0x80) == 0) { - // just one byte - return firstByte & 0x7F; - } - if ((firstByte & 0xC0) == 0x80) { - // two bytes - var secondByte = bits.readBits(8); - return ((firstByte & 0x3F) << 8) | secondByte; - } - if ((firstByte & 0xE0) == 0xC0) { - // three bytes - var secondThirdBytes = bits.readBits(16); - return ((firstByte & 0x1F) << 16) | secondThirdBytes; - } - throw new Error("Bad ECI bits starting with byte " + firstByte); - } - function decodeHanziSegment(bits, result, count) { - // Don't crash trying to read more bits than we have available. - if (count * 13 > bits.available()) { - return false; - } - // Each character will require 2 bytes. Read the characters as 2-byte pairs - // and decode as GB2312 afterwards - var buffer = new Array(2 * count); - var offset = 0; - while (count > 0) { - // Each 13 bits encodes a 2-byte character - var twoBytes = bits.readBits(13); - var assembledTwoBytes = (Math.floor(twoBytes / 0x060) << 8) | (twoBytes % 0x060); - if (assembledTwoBytes < 0x003BF) { - // In the 0xA1A1 to 0xAAFE range - assembledTwoBytes += 0x0A1A1; - } - else { - // In the 0xB0A1 to 0xFAFE range - assembledTwoBytes += 0x0A6A1; - } - buffer[offset] = ((assembledTwoBytes >> 8) & 0xFF); - buffer[offset + 1] = (assembledTwoBytes & 0xFF); - offset += 2; - count--; - } - result.val = buffer; - return true; - } - function decodeNumericSegment(bits, result, count) { - // Read three digits at a time - while (count >= 3) { - // Each 10 bits encodes three digits - if (bits.available() < 10) { - return false; - } - var threeDigitsBits = bits.readBits(10); - if (threeDigitsBits >= 1000) { - return false; - } - result.val.push(toAlphaNumericByte(Math.floor(threeDigitsBits / 100))); - result.val.push(toAlphaNumericByte(Math.floor(threeDigitsBits / 10) % 10)); - result.val.push(toAlphaNumericByte(threeDigitsBits % 10)); - count -= 3; - } - if (count == 2) { - // Two digits left over to read, encoded in 7 bits - if (bits.available() < 7) { - return false; - } - var twoDigitsBits = bits.readBits(7); - if (twoDigitsBits >= 100) { - return false; - } - result.val.push(toAlphaNumericByte(Math.floor(twoDigitsBits / 10))); - result.val.push(toAlphaNumericByte(twoDigitsBits % 10)); - } - else if (count == 1) { - // One digit left over to read - if (bits.available() < 4) { - return false; - } - var digitBits = bits.readBits(4); - if (digitBits >= 10) { - return false; - } - result.val.push(toAlphaNumericByte(digitBits)); - } - return true; - } - function decodeAlphanumericSegment(bits, result, count, fc1InEffect) { - // Read two characters at a time - var start = result.val.length; - while (count > 1) { - if (bits.available() < 11) { - return false; - } - var nextTwoCharsBits = bits.readBits(11); - result.val.push(toAlphaNumericByte(Math.floor(nextTwoCharsBits / 45))); - result.val.push(toAlphaNumericByte(nextTwoCharsBits % 45)); - count -= 2; - } - if (count == 1) { - // special case: one character left - if (bits.available() < 6) { - return false; - } - result.val.push(toAlphaNumericByte(bits.readBits(6))); - } - // See section 6.4.8.1, 6.4.8.2 - if (fc1InEffect) { - // We need to massage the result a bit if in an FNC1 mode: - for (var i = start; i < result.val.length; i++) { - if (result.val[i] == '%'.charCodeAt(0)) { - if (i < result.val.length - 1 && result.val[i + 1] == '%'.charCodeAt(0)) { - // %% is rendered as % - result.val = result.val.slice(0, i + 1).concat(result.val.slice(i + 2)); - } - else { - // In alpha mode, % should be converted to FNC1 separator 0x1D - // THIS IS ALMOST CERTAINLY INVALID - result.val[i] = 0x1D; - } - } - } - } - return true; - } - function decodeByteSegment(bits, result, count) { - // Don't crash trying to read more bits than we have available. - if (count << 3 > bits.available()) { - return false; - } - var readBytes = new Array(count); - for (var i = 0; i < count; i++) { - readBytes[i] = bits.readBits(8); - } - Array.prototype.push.apply(result.val, readBytes); - return true; - } - var GB2312_SUBSET = 1; - // Takes in a byte array, a qr version number and an error correction level. - // Returns decoded data. - function decodeQRdata(data, version, ecl) { - var symbolSequence = -1; - var parityData = -1; - var bits = new bitstream_1.BitStream(data); - var result = { val: [] }; // Have to pass this around so functions can share a reference to a number[] - var fc1InEffect = false; - var mode; - while (mode != TERMINATOR_MODE) { - // While still another segment to read... - if (bits.available() < 4) { - // OK, assume we're done. Really, a TERMINATOR mode should have been recorded here - mode = TERMINATOR_MODE; - } - else { - mode = modeForBits(bits.readBits(4)); // mode is encoded by 4 bits - } - if (mode != TERMINATOR_MODE) { - if (mode == FNC1_FIRST_POSITION_MODE || mode == FNC1_SECOND_POSITION_MODE) { - // We do little with FNC1 except alter the parsed result a bit according to the spec - fc1InEffect = true; - } - else if (mode == STRUCTURED_APPEND_MODE) { - if (bits.available() < 16) { - return null; - } - // not really supported; but sequence number and parity is added later to the result metadata - // Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue - symbolSequence = bits.readBits(8); - parityData = bits.readBits(8); - } - else if (mode == ECI_MODE) { - // Ignore since we don't do character encoding in JS - var value = parseECIValue(bits); - if (value < 0 || value > 30) { - return null; - } - } - else { - // First handle Hanzi mode which does not start with character count - if (mode == HANZI_MODE) { - //chinese mode contains a sub set indicator right after mode indicator - var subset = bits.readBits(4); - var countHanzi = bits.readBits(mode.getCharacterCountBits(version)); - if (subset == GB2312_SUBSET) { - if (!decodeHanziSegment(bits, result, countHanzi)) { - return null; - } - } - } - else { - // "Normal" QR code modes: - // How many characters will follow, encoded in this mode? - var count = bits.readBits(mode.getCharacterCountBits(version)); - if (mode == NUMERIC_MODE) { - if (!decodeNumericSegment(bits, result, count)) { - return null; - } - } - else if (mode == ALPHANUMERIC_MODE) { - if (!decodeAlphanumericSegment(bits, result, count, fc1InEffect)) { - return null; - } - } - else if (mode == BYTE_MODE) { - if (!decodeByteSegment(bits, result, count)) { - return null; - } - } - else if (mode == KANJI_MODE) { - } - else { - return null; - } - } - } - } - } - return result.val; - } - exports.decodeQRdata = decodeQRdata; + "use strict"; + var bitstream_1 = __webpack_require__(11); + function toAlphaNumericByte(value) { + var ALPHANUMERIC_CHARS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', + 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', + 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + ' ', '$', '%', '*', '+', '-', '.', '/', ':']; + if (value >= ALPHANUMERIC_CHARS.length) { + throw new Error("Could not decode alphanumeric char"); + } + return ALPHANUMERIC_CHARS[value].charCodeAt(0); + } + var Mode = (function () { + function Mode(characterCountBitsForVersions, bits) { + this.characterCountBitsForVersions = characterCountBitsForVersions; + this.bits = bits; + } + Mode.prototype.getCharacterCountBits = function (version) { + if (this.characterCountBitsForVersions == null) { + throw new Error("Character count doesn't apply to this mode"); + } + var offset; + if (version <= 9) { + offset = 0; + } + else if (version <= 26) { + offset = 1; + } + else { + offset = 2; + } + return this.characterCountBitsForVersions[offset]; + }; + return Mode; + }()); + var TERMINATOR_MODE = new Mode([0, 0, 0], 0x00); // Not really a mod... + var NUMERIC_MODE = new Mode([10, 12, 14], 0x01); + var ALPHANUMERIC_MODE = new Mode([9, 11, 13], 0x02); + var STRUCTURED_APPEND_MODE = new Mode([0, 0, 0], 0x03); // Not supported + var BYTE_MODE = new Mode([8, 16, 16], 0x04); + var ECI_MODE = new Mode(null, 0x07); // character counts don't apply + var KANJI_MODE = new Mode([8, 10, 12], 0x08); + var FNC1_FIRST_POSITION_MODE = new Mode(null, 0x05); + var FNC1_SECOND_POSITION_MODE = new Mode(null, 0x09); + var HANZI_MODE = new Mode([8, 10, 12], 0x0D); + function modeForBits(bits) { + switch (bits) { + case 0x0: + return TERMINATOR_MODE; + case 0x1: + return NUMERIC_MODE; + case 0x2: + return ALPHANUMERIC_MODE; + case 0x3: + return STRUCTURED_APPEND_MODE; + case 0x4: + return BYTE_MODE; + case 0x5: + return FNC1_FIRST_POSITION_MODE; + case 0x7: + return ECI_MODE; + case 0x8: + return KANJI_MODE; + case 0x9: + return FNC1_SECOND_POSITION_MODE; + case 0xD: + // 0xD is defined in GBT 18284-2000, may not be supported in foreign country + return HANZI_MODE; + default: + throw new Error("Couldn't decode mode from byte array"); + } + } + function parseECIValue(bits) { + var firstByte = bits.readBits(8); + if ((firstByte & 0x80) == 0) { + // just one byte + return firstByte & 0x7F; + } + if ((firstByte & 0xC0) == 0x80) { + // two bytes + var secondByte = bits.readBits(8); + return ((firstByte & 0x3F) << 8) | secondByte; + } + if ((firstByte & 0xE0) == 0xC0) { + // three bytes + var secondThirdBytes = bits.readBits(16); + return ((firstByte & 0x1F) << 16) | secondThirdBytes; + } + throw new Error("Bad ECI bits starting with byte " + firstByte); + } + function decodeHanziSegment(bits, result, count) { + // Don't crash trying to read more bits than we have available. + if (count * 13 > bits.available()) { + return false; + } + // Each character will require 2 bytes. Read the characters as 2-byte pairs + // and decode as GB2312 afterwards + var buffer = new Array(2 * count); + var offset = 0; + while (count > 0) { + // Each 13 bits encodes a 2-byte character + var twoBytes = bits.readBits(13); + var assembledTwoBytes = (Math.floor(twoBytes / 0x060) << 8) | (twoBytes % 0x060); + if (assembledTwoBytes < 0x003BF) { + // In the 0xA1A1 to 0xAAFE range + assembledTwoBytes += 0x0A1A1; + } + else { + // In the 0xB0A1 to 0xFAFE range + assembledTwoBytes += 0x0A6A1; + } + buffer[offset] = ((assembledTwoBytes >> 8) & 0xFF); + buffer[offset + 1] = (assembledTwoBytes & 0xFF); + offset += 2; + count--; + } + result.val = buffer; + return true; + } + function decodeNumericSegment(bits, result, count) { + // Read three digits at a time + while (count >= 3) { + // Each 10 bits encodes three digits + if (bits.available() < 10) { + return false; + } + var threeDigitsBits = bits.readBits(10); + if (threeDigitsBits >= 1000) { + return false; + } + result.val.push(toAlphaNumericByte(Math.floor(threeDigitsBits / 100))); + result.val.push(toAlphaNumericByte(Math.floor(threeDigitsBits / 10) % 10)); + result.val.push(toAlphaNumericByte(threeDigitsBits % 10)); + count -= 3; + } + if (count == 2) { + // Two digits left over to read, encoded in 7 bits + if (bits.available() < 7) { + return false; + } + var twoDigitsBits = bits.readBits(7); + if (twoDigitsBits >= 100) { + return false; + } + result.val.push(toAlphaNumericByte(Math.floor(twoDigitsBits / 10))); + result.val.push(toAlphaNumericByte(twoDigitsBits % 10)); + } + else if (count == 1) { + // One digit left over to read + if (bits.available() < 4) { + return false; + } + var digitBits = bits.readBits(4); + if (digitBits >= 10) { + return false; + } + result.val.push(toAlphaNumericByte(digitBits)); + } + return true; + } + function decodeAlphanumericSegment(bits, result, count, fc1InEffect) { + // Read two characters at a time + var start = result.val.length; + while (count > 1) { + if (bits.available() < 11) { + return false; + } + var nextTwoCharsBits = bits.readBits(11); + result.val.push(toAlphaNumericByte(Math.floor(nextTwoCharsBits / 45))); + result.val.push(toAlphaNumericByte(nextTwoCharsBits % 45)); + count -= 2; + } + if (count == 1) { + // special case: one character left + if (bits.available() < 6) { + return false; + } + result.val.push(toAlphaNumericByte(bits.readBits(6))); + } + // See section 6.4.8.1, 6.4.8.2 + if (fc1InEffect) { + // We need to massage the result a bit if in an FNC1 mode: + for (var i = start; i < result.val.length; i++) { + if (result.val[i] == '%'.charCodeAt(0)) { + if (i < result.val.length - 1 && result.val[i + 1] == '%'.charCodeAt(0)) { + // %% is rendered as % + result.val = result.val.slice(0, i + 1).concat(result.val.slice(i + 2)); + } + else { + // In alpha mode, % should be converted to FNC1 separator 0x1D + // THIS IS ALMOST CERTAINLY INVALID + result.val[i] = 0x1D; + } + } + } + } + return true; + } + function decodeByteSegment(bits, result, count) { + // Don't crash trying to read more bits than we have available. + if (count << 3 > bits.available()) { + return false; + } + var readBytes = new Array(count); + for (var i = 0; i < count; i++) { + readBytes[i] = bits.readBits(8); + } + Array.prototype.push.apply(result.val, readBytes); + return true; + } + var GB2312_SUBSET = 1; + // Takes in a byte array, a qr version number and an error correction level. + // Returns decoded data. + function decodeQRdata(data, version, ecl) { + var symbolSequence = -1; + var parityData = -1; + var bits = new bitstream_1.BitStream(data); + var result = { val: [] }; // Have to pass this around so functions can share a reference to a number[] + var fc1InEffect = false; + var mode; + while (mode != TERMINATOR_MODE) { + // While still another segment to read... + if (bits.available() < 4) { + // OK, assume we're done. Really, a TERMINATOR mode should have been recorded here + mode = TERMINATOR_MODE; + } + else { + mode = modeForBits(bits.readBits(4)); // mode is encoded by 4 bits + } + if (mode != TERMINATOR_MODE) { + if (mode == FNC1_FIRST_POSITION_MODE || mode == FNC1_SECOND_POSITION_MODE) { + // We do little with FNC1 except alter the parsed result a bit according to the spec + fc1InEffect = true; + } + else if (mode == STRUCTURED_APPEND_MODE) { + if (bits.available() < 16) { + return null; + } + // not really supported; but sequence number and parity is added later to the result metadata + // Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue + symbolSequence = bits.readBits(8); + parityData = bits.readBits(8); + } + else if (mode == ECI_MODE) { + // Ignore since we don't do character encoding in JS + var value = parseECIValue(bits); + if (value < 0 || value > 30) { + return null; + } + } + else { + // First handle Hanzi mode which does not start with character count + if (mode == HANZI_MODE) { + //chinese mode contains a sub set indicator right after mode indicator + var subset = bits.readBits(4); + var countHanzi = bits.readBits(mode.getCharacterCountBits(version)); + if (subset == GB2312_SUBSET) { + if (!decodeHanziSegment(bits, result, countHanzi)) { + return null; + } + } + } + else { + // "Normal" QR code modes: + // How many characters will follow, encoded in this mode? + var count = bits.readBits(mode.getCharacterCountBits(version)); + if (mode == NUMERIC_MODE) { + if (!decodeNumericSegment(bits, result, count)) { + return null; + } + } + else if (mode == ALPHANUMERIC_MODE) { + if (!decodeAlphanumericSegment(bits, result, count, fc1InEffect)) { + return null; + } + } + else if (mode == BYTE_MODE) { + if (!decodeByteSegment(bits, result, count)) { + return null; + } + } + else if (mode == KANJI_MODE) { + } + else { + return null; + } + } + } + } + } + return result.val; + } + exports.decodeQRdata = decodeQRdata; /***/ }, /* 11 */ /***/ function(module, exports) { - "use strict"; - var BitStream = (function () { - function BitStream(bytes) { - this.byteOffset = 0; - this.bitOffset = 0; - this.bytes = bytes; - } - BitStream.prototype.readBits = function (numBits) { - if (numBits < 1 || numBits > 32 || numBits > this.available()) { - throw new Error("Cannot read " + numBits.toString() + " bits"); - } - var result = 0; - // First, read remainder from current byte - if (this.bitOffset > 0) { - var bitsLeft = 8 - this.bitOffset; - var toRead = numBits < bitsLeft ? numBits : bitsLeft; - var bitsToNotRead = bitsLeft - toRead; - var mask = (0xFF >> (8 - toRead)) << bitsToNotRead; - result = (this.bytes[this.byteOffset] & mask) >> bitsToNotRead; - numBits -= toRead; - this.bitOffset += toRead; - if (this.bitOffset == 8) { - this.bitOffset = 0; - this.byteOffset++; - } - } - // Next read whole bytes - if (numBits > 0) { - while (numBits >= 8) { - result = (result << 8) | (this.bytes[this.byteOffset] & 0xFF); - this.byteOffset++; - numBits -= 8; - } - // Finally read a partial byte - if (numBits > 0) { - var bitsToNotRead = 8 - numBits; - var mask = (0xFF >> bitsToNotRead) << bitsToNotRead; - result = (result << numBits) | ((this.bytes[this.byteOffset] & mask) >> bitsToNotRead); - this.bitOffset += numBits; - } - } - return result; - }; - BitStream.prototype.available = function () { - return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset; - }; - return BitStream; - }()); - exports.BitStream = BitStream; + "use strict"; + var BitStream = (function () { + function BitStream(bytes) { + this.byteOffset = 0; + this.bitOffset = 0; + this.bytes = bytes; + } + BitStream.prototype.readBits = function (numBits) { + if (numBits < 1 || numBits > 32 || numBits > this.available()) { + throw new Error("Cannot read " + numBits.toString() + " bits"); + } + var result = 0; + // First, read remainder from current byte + if (this.bitOffset > 0) { + var bitsLeft = 8 - this.bitOffset; + var toRead = numBits < bitsLeft ? numBits : bitsLeft; + var bitsToNotRead = bitsLeft - toRead; + var mask = (0xFF >> (8 - toRead)) << bitsToNotRead; + result = (this.bytes[this.byteOffset] & mask) >> bitsToNotRead; + numBits -= toRead; + this.bitOffset += toRead; + if (this.bitOffset == 8) { + this.bitOffset = 0; + this.byteOffset++; + } + } + // Next read whole bytes + if (numBits > 0) { + while (numBits >= 8) { + result = (result << 8) | (this.bytes[this.byteOffset] & 0xFF); + this.byteOffset++; + numBits -= 8; + } + // Finally read a partial byte + if (numBits > 0) { + var bitsToNotRead = 8 - numBits; + var mask = (0xFF >> bitsToNotRead) << bitsToNotRead; + result = (result << numBits) | ((this.bytes[this.byteOffset] & mask) >> bitsToNotRead); + this.bitOffset += numBits; + } + } + return result; + }; + BitStream.prototype.available = function () { + return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset; + }; + return BitStream; + }()); + exports.BitStream = BitStream; /***/ }, /* 12 */ /***/ function(module, exports) { - "use strict"; - var ReedSolomonDecoder = (function () { - function ReedSolomonDecoder() { - this.field = new GenericGF(0x011D, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1 - } - ReedSolomonDecoder.prototype.decode = function (received, twoS) { - var poly = new GenericGFPoly(this.field, received); - var syndromeCoefficients = new Array(twoS); - var noError = true; - for (var i = 0; i < twoS; i++) { - var evaluation = poly.evaluateAt(this.field.exp(i + this.field.generatorBase)); - syndromeCoefficients[syndromeCoefficients.length - 1 - i] = evaluation; - if (evaluation != 0) { - noError = false; - } - } - if (noError) { - return true; - } - var syndrome = new GenericGFPoly(this.field, syndromeCoefficients); - var sigmaOmega = this.runEuclideanAlgorithm(this.field.buildMonomial(twoS, 1), syndrome, twoS); - if (sigmaOmega == null) - return false; - var sigma = sigmaOmega[0]; - var errorLocations = this.findErrorLocations(sigma); - if (errorLocations == null) - return false; - var omega = sigmaOmega[1]; - var errorMagnitudes = this.findErrorMagnitudes(omega, errorLocations); - for (var i = 0; i < errorLocations.length; i++) { - var position = received.length - 1 - this.field.log(errorLocations[i]); - if (position < 0) { - // throw new ReedSolomonException("Bad error location"); - return false; - } - received[position] = GenericGF.addOrSubtract(received[position], errorMagnitudes[i]); - } - return true; - }; - ReedSolomonDecoder.prototype.runEuclideanAlgorithm = function (a, b, R) { - // Assume a's degree is >= b's - if (a.degree() < b.degree()) { - var temp = a; - a = b; - b = temp; - } - var rLast = a; - var r = b; - var tLast = this.field.zero; - var t = this.field.one; - // Run Euclidean algorithm until r's degree is less than R/2 - while (r.degree() >= R / 2) { - var rLastLast = rLast; - var tLastLast = tLast; - rLast = r; - tLast = t; - // Divide rLastLast by rLast, with quotient in q and remainder in r - if (rLast.isZero()) { - // Oops, Euclidean algorithm already terminated? - // throw new ReedSolomonException("r_{i-1} was zero"); - return null; - } - r = rLastLast; - var q = this.field.zero; - var denominatorLeadingTerm = rLast.getCoefficient(rLast.degree()); - var dltInverse = this.field.inverse(denominatorLeadingTerm); - while (r.degree() >= rLast.degree() && !r.isZero()) { - var degreeDiff = r.degree() - rLast.degree(); - var scale = this.field.multiply(r.getCoefficient(r.degree()), dltInverse); - q = q.addOrSubtract(this.field.buildMonomial(degreeDiff, scale)); - r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale)); - } - t = q.multiplyPoly(tLast).addOrSubtract(tLastLast); - if (r.degree() >= rLast.degree()) { - // throw new IllegalStateException("Division algorithm failed to reduce polynomial?"); - return null; - } - } - var sigmaTildeAtZero = t.getCoefficient(0); - if (sigmaTildeAtZero == 0) { - // throw new ReedSolomonException("sigmaTilde(0) was zero"); - return null; - } - var inverse = this.field.inverse(sigmaTildeAtZero); - var sigma = t.multiply(inverse); - var omega = r.multiply(inverse); - return [sigma, omega]; - }; - ReedSolomonDecoder.prototype.findErrorLocations = function (errorLocator) { - // This is a direct application of Chien's search - var numErrors = errorLocator.degree(); - if (numErrors == 1) { - // shortcut - return [errorLocator.getCoefficient(1)]; - } - var result = new Array(numErrors); - var e = 0; - for (var i = 1; i < this.field.size && e < numErrors; i++) { - if (errorLocator.evaluateAt(i) == 0) { - result[e] = this.field.inverse(i); - e++; - } - } - if (e != numErrors) { - // throw new ReedSolomonException("Error locator degree does not match number of roots"); - return null; - } - return result; - }; - ReedSolomonDecoder.prototype.findErrorMagnitudes = function (errorEvaluator, errorLocations) { - // This is directly applying Forney's Formula - var s = errorLocations.length; - var result = new Array(s); - for (var i = 0; i < s; i++) { - var xiInverse = this.field.inverse(errorLocations[i]); - var denominator = 1; - for (var j = 0; j < s; j++) { - if (i != j) { - //denominator = field.multiply(denominator, - // GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse))); - // Above should work but fails on some Apple and Linux JDKs due to a Hotspot bug. - // Below is a funny-looking workaround from Steven Parkes - var term = this.field.multiply(errorLocations[j], xiInverse); - var termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1; - denominator = this.field.multiply(denominator, termPlus1); - } - } - result[i] = this.field.multiply(errorEvaluator.evaluateAt(xiInverse), this.field.inverse(denominator)); - if (this.field.generatorBase != 0) { - result[i] = this.field.multiply(result[i], xiInverse); - } - } - return result; - }; - return ReedSolomonDecoder; - }()); - exports.ReedSolomonDecoder = ReedSolomonDecoder; - var GenericGFPoly = (function () { - function GenericGFPoly(field, coefficients) { - if (coefficients.length == 0) { - throw new Error("No coefficients."); - } - this.field = field; - var coefficientsLength = coefficients.length; - if (coefficientsLength > 1 && coefficients[0] == 0) { - // Leading term must be non-zero for anything except the constant polynomial "0" - var firstNonZero = 1; - while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) { - firstNonZero++; - } - if (firstNonZero == coefficientsLength) { - this.coefficients = field.zero.coefficients; - } - else { - this.coefficients = new Array(coefficientsLength - firstNonZero); - /*Array.Copy(coefficients, // Source array - firstNonZero, // Source index - this.coefficients, // Destination array - 0, // Destination index - this.coefficients.length); // length*/ - for (var i = 0; i < this.coefficients.length; i++) { - this.coefficients[i] = coefficients[firstNonZero + i]; - } - } - } - else { - this.coefficients = coefficients; - } - } - GenericGFPoly.prototype.evaluateAt = function (a) { - var result = 0; - if (a == 0) { - // Just return the x^0 coefficient - return this.getCoefficient(0); - } - var size = this.coefficients.length; - if (a == 1) { - // Just the sum of the coefficients - this.coefficients.forEach(function (coefficient) { - result = GenericGF.addOrSubtract(result, coefficient); - }); - return result; - } - result = this.coefficients[0]; - for (var i = 1; i < size; i++) { - result = GenericGF.addOrSubtract(this.field.multiply(a, result), this.coefficients[i]); - } - return result; - }; - GenericGFPoly.prototype.getCoefficient = function (degree) { - return this.coefficients[this.coefficients.length - 1 - degree]; - }; - GenericGFPoly.prototype.degree = function () { - return this.coefficients.length - 1; - }; - GenericGFPoly.prototype.isZero = function () { - return this.coefficients[0] == 0; - }; - GenericGFPoly.prototype.addOrSubtract = function (other) { - /* TODO, fix this. - if (!this.field.Equals(other.field)) - { - throw new Error("GenericGFPolys do not have same GenericGF field"); - }*/ - if (this.isZero()) { - return other; - } - if (other.isZero()) { - return this; - } - var smallerCoefficients = this.coefficients; - var largerCoefficients = other.coefficients; - if (smallerCoefficients.length > largerCoefficients.length) { - var temp = smallerCoefficients; - smallerCoefficients = largerCoefficients; - largerCoefficients = temp; - } - var sumDiff = new Array(largerCoefficients.length); - var lengthDiff = largerCoefficients.length - smallerCoefficients.length; - // Copy high-order terms only found in higher-degree polynomial's coefficients - ///Array.Copy(largerCoefficients, 0, sumDiff, 0, lengthDiff); - for (var i = 0; i < lengthDiff; i++) { - sumDiff[i] = largerCoefficients[i]; - } - for (var i = lengthDiff; i < largerCoefficients.length; i++) { - sumDiff[i] = GenericGF.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]); - } - return new GenericGFPoly(this.field, sumDiff); - }; - GenericGFPoly.prototype.multiply = function (scalar) { - if (scalar == 0) { - return this.field.zero; - } - if (scalar == 1) { - return this; - } - var size = this.coefficients.length; - var product = new Array(size); - for (var i = 0; i < size; i++) { - product[i] = this.field.multiply(this.coefficients[i], scalar); - } - return new GenericGFPoly(this.field, product); - }; - GenericGFPoly.prototype.multiplyPoly = function (other) { - /* TODO Fix this. - if (!field.Equals(other.field)) - { - throw new Error("GenericGFPolys do not have same GenericGF field"); - }*/ - if (this.isZero() || other.isZero()) { - return this.field.zero; - } - var aCoefficients = this.coefficients; - var aLength = aCoefficients.length; - var bCoefficients = other.coefficients; - var bLength = bCoefficients.length; - var product = new Array(aLength + bLength - 1); - for (var i = 0; i < aLength; i++) { - var aCoeff = aCoefficients[i]; - for (var j = 0; j < bLength; j++) { - product[i + j] = GenericGF.addOrSubtract(product[i + j], this.field.multiply(aCoeff, bCoefficients[j])); - } - } - return new GenericGFPoly(this.field, product); - }; - GenericGFPoly.prototype.multiplyByMonomial = function (degree, coefficient) { - if (degree < 0) { - throw new Error("Invalid degree less than 0"); - } - if (coefficient == 0) { - return this.field.zero; - } - var size = this.coefficients.length; - var product = new Array(size + degree); - for (var i = 0; i < size; i++) { - product[i] = this.field.multiply(this.coefficients[i], coefficient); - } - return new GenericGFPoly(this.field, product); - }; - return GenericGFPoly; - }()); - var GenericGF = (function () { - function GenericGF(primitive, size, genBase) { - // ok. - this.INITIALIZATION_THRESHOLD = 0; - this.initialized = false; - this.primitive = primitive; - this.size = size; - this.generatorBase = genBase; - if (size <= this.INITIALIZATION_THRESHOLD) { - this.initialize(); - } - } - GenericGF.prototype.initialize = function () { - this.expTable = new Array(this.size); - this.logTable = new Array(this.size); - var x = 1; - for (var i = 0; i < this.size; i++) { - this.expTable[i] = x; - x <<= 1; // x = x * 2; we're assuming the generator alpha is 2 - if (x >= this.size) { - x ^= this.primitive; - x &= this.size - 1; - } - } - for (var i = 0; i < this.size - 1; i++) { - this.logTable[this.expTable[i]] = i; - } - // logTable[0] == 0 but this should never be used - this.zero = new GenericGFPoly(this, [0]); - this.one = new GenericGFPoly(this, [1]); - this.initialized = true; - }; - GenericGF.addOrSubtract = function (a, b) { - return a ^ b; - }; - GenericGF.prototype.checkInit = function () { - if (!this.initialized) - this.initialize(); - }; - GenericGF.prototype.multiply = function (a, b) { - this.checkInit(); - if (a == 0 || b == 0) { - return 0; - } - return this.expTable[(this.logTable[a] + this.logTable[b]) % (this.size - 1)]; - }; - GenericGF.prototype.exp = function (a) { - this.checkInit(); - return this.expTable[a]; - }; - GenericGF.prototype.log = function (a) { - this.checkInit(); - if (a == 0) { - throw new Error("Can't take log(0)"); - } - return this.logTable[a]; - }; - GenericGF.prototype.inverse = function (a) { - this.checkInit(); - if (a == 0) { - throw new Error("Can't invert 0"); - } - return this.expTable[this.size - this.logTable[a] - 1]; - }; - GenericGF.prototype.buildMonomial = function (degree, coefficient) { - this.checkInit(); - if (degree < 0) { - throw new Error("Invalid monomial degree less than 0"); - } - if (coefficient == 0) { - return this.zero; - } - var coefficients = new Array(degree + 1); - coefficients[0] = coefficient; - return new GenericGFPoly(this, coefficients); - }; - return GenericGF; - }()); + "use strict"; + var ReedSolomonDecoder = (function () { + function ReedSolomonDecoder() { + this.field = new GenericGF(0x011D, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1 + } + ReedSolomonDecoder.prototype.decode = function (received, twoS) { + var poly = new GenericGFPoly(this.field, received); + var syndromeCoefficients = new Array(twoS); + var noError = true; + for (var i = 0; i < twoS; i++) { + var evaluation = poly.evaluateAt(this.field.exp(i + this.field.generatorBase)); + syndromeCoefficients[syndromeCoefficients.length - 1 - i] = evaluation; + if (evaluation != 0) { + noError = false; + } + } + if (noError) { + return true; + } + var syndrome = new GenericGFPoly(this.field, syndromeCoefficients); + var sigmaOmega = this.runEuclideanAlgorithm(this.field.buildMonomial(twoS, 1), syndrome, twoS); + if (sigmaOmega == null) + return false; + var sigma = sigmaOmega[0]; + var errorLocations = this.findErrorLocations(sigma); + if (errorLocations == null) + return false; + var omega = sigmaOmega[1]; + var errorMagnitudes = this.findErrorMagnitudes(omega, errorLocations); + for (var i = 0; i < errorLocations.length; i++) { + var position = received.length - 1 - this.field.log(errorLocations[i]); + if (position < 0) { + // throw new ReedSolomonException("Bad error location"); + return false; + } + received[position] = GenericGF.addOrSubtract(received[position], errorMagnitudes[i]); + } + return true; + }; + ReedSolomonDecoder.prototype.runEuclideanAlgorithm = function (a, b, R) { + // Assume a's degree is >= b's + if (a.degree() < b.degree()) { + var temp = a; + a = b; + b = temp; + } + var rLast = a; + var r = b; + var tLast = this.field.zero; + var t = this.field.one; + // Run Euclidean algorithm until r's degree is less than R/2 + while (r.degree() >= R / 2) { + var rLastLast = rLast; + var tLastLast = tLast; + rLast = r; + tLast = t; + // Divide rLastLast by rLast, with quotient in q and remainder in r + if (rLast.isZero()) { + // Oops, Euclidean algorithm already terminated? + // throw new ReedSolomonException("r_{i-1} was zero"); + return null; + } + r = rLastLast; + var q = this.field.zero; + var denominatorLeadingTerm = rLast.getCoefficient(rLast.degree()); + var dltInverse = this.field.inverse(denominatorLeadingTerm); + while (r.degree() >= rLast.degree() && !r.isZero()) { + var degreeDiff = r.degree() - rLast.degree(); + var scale = this.field.multiply(r.getCoefficient(r.degree()), dltInverse); + q = q.addOrSubtract(this.field.buildMonomial(degreeDiff, scale)); + r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale)); + } + t = q.multiplyPoly(tLast).addOrSubtract(tLastLast); + if (r.degree() >= rLast.degree()) { + // throw new IllegalStateException("Division algorithm failed to reduce polynomial?"); + return null; + } + } + var sigmaTildeAtZero = t.getCoefficient(0); + if (sigmaTildeAtZero == 0) { + // throw new ReedSolomonException("sigmaTilde(0) was zero"); + return null; + } + var inverse = this.field.inverse(sigmaTildeAtZero); + var sigma = t.multiply(inverse); + var omega = r.multiply(inverse); + return [sigma, omega]; + }; + ReedSolomonDecoder.prototype.findErrorLocations = function (errorLocator) { + // This is a direct application of Chien's search + var numErrors = errorLocator.degree(); + if (numErrors == 1) { + // shortcut + return [errorLocator.getCoefficient(1)]; + } + var result = new Array(numErrors); + var e = 0; + for (var i = 1; i < this.field.size && e < numErrors; i++) { + if (errorLocator.evaluateAt(i) == 0) { + result[e] = this.field.inverse(i); + e++; + } + } + if (e != numErrors) { + // throw new ReedSolomonException("Error locator degree does not match number of roots"); + return null; + } + return result; + }; + ReedSolomonDecoder.prototype.findErrorMagnitudes = function (errorEvaluator, errorLocations) { + // This is directly applying Forney's Formula + var s = errorLocations.length; + var result = new Array(s); + for (var i = 0; i < s; i++) { + var xiInverse = this.field.inverse(errorLocations[i]); + var denominator = 1; + for (var j = 0; j < s; j++) { + if (i != j) { + //denominator = field.multiply(denominator, + // GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse))); + // Above should work but fails on some Apple and Linux JDKs due to a Hotspot bug. + // Below is a funny-looking workaround from Steven Parkes + var term = this.field.multiply(errorLocations[j], xiInverse); + var termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1; + denominator = this.field.multiply(denominator, termPlus1); + } + } + result[i] = this.field.multiply(errorEvaluator.evaluateAt(xiInverse), this.field.inverse(denominator)); + if (this.field.generatorBase != 0) { + result[i] = this.field.multiply(result[i], xiInverse); + } + } + return result; + }; + return ReedSolomonDecoder; + }()); + exports.ReedSolomonDecoder = ReedSolomonDecoder; + var GenericGFPoly = (function () { + function GenericGFPoly(field, coefficients) { + if (coefficients.length == 0) { + throw new Error("No coefficients."); + } + this.field = field; + var coefficientsLength = coefficients.length; + if (coefficientsLength > 1 && coefficients[0] == 0) { + // Leading term must be non-zero for anything except the constant polynomial "0" + var firstNonZero = 1; + while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) { + firstNonZero++; + } + if (firstNonZero == coefficientsLength) { + this.coefficients = field.zero.coefficients; + } + else { + this.coefficients = new Array(coefficientsLength - firstNonZero); + /*Array.Copy(coefficients, // Source array + firstNonZero, // Source index + this.coefficients, // Destination array + 0, // Destination index + this.coefficients.length); // length*/ + for (var i = 0; i < this.coefficients.length; i++) { + this.coefficients[i] = coefficients[firstNonZero + i]; + } + } + } + else { + this.coefficients = coefficients; + } + } + GenericGFPoly.prototype.evaluateAt = function (a) { + var result = 0; + if (a == 0) { + // Just return the x^0 coefficient + return this.getCoefficient(0); + } + var size = this.coefficients.length; + if (a == 1) { + // Just the sum of the coefficients + this.coefficients.forEach(function (coefficient) { + result = GenericGF.addOrSubtract(result, coefficient); + }); + return result; + } + result = this.coefficients[0]; + for (var i = 1; i < size; i++) { + result = GenericGF.addOrSubtract(this.field.multiply(a, result), this.coefficients[i]); + } + return result; + }; + GenericGFPoly.prototype.getCoefficient = function (degree) { + return this.coefficients[this.coefficients.length - 1 - degree]; + }; + GenericGFPoly.prototype.degree = function () { + return this.coefficients.length - 1; + }; + GenericGFPoly.prototype.isZero = function () { + return this.coefficients[0] == 0; + }; + GenericGFPoly.prototype.addOrSubtract = function (other) { + /* TODO, fix this. + if (!this.field.Equals(other.field)) + { + throw new Error("GenericGFPolys do not have same GenericGF field"); + }*/ + if (this.isZero()) { + return other; + } + if (other.isZero()) { + return this; + } + var smallerCoefficients = this.coefficients; + var largerCoefficients = other.coefficients; + if (smallerCoefficients.length > largerCoefficients.length) { + var temp = smallerCoefficients; + smallerCoefficients = largerCoefficients; + largerCoefficients = temp; + } + var sumDiff = new Array(largerCoefficients.length); + var lengthDiff = largerCoefficients.length - smallerCoefficients.length; + // Copy high-order terms only found in higher-degree polynomial's coefficients + ///Array.Copy(largerCoefficients, 0, sumDiff, 0, lengthDiff); + for (var i = 0; i < lengthDiff; i++) { + sumDiff[i] = largerCoefficients[i]; + } + for (var i = lengthDiff; i < largerCoefficients.length; i++) { + sumDiff[i] = GenericGF.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]); + } + return new GenericGFPoly(this.field, sumDiff); + }; + GenericGFPoly.prototype.multiply = function (scalar) { + if (scalar == 0) { + return this.field.zero; + } + if (scalar == 1) { + return this; + } + var size = this.coefficients.length; + var product = new Array(size); + for (var i = 0; i < size; i++) { + product[i] = this.field.multiply(this.coefficients[i], scalar); + } + return new GenericGFPoly(this.field, product); + }; + GenericGFPoly.prototype.multiplyPoly = function (other) { + /* TODO Fix this. + if (!field.Equals(other.field)) + { + throw new Error("GenericGFPolys do not have same GenericGF field"); + }*/ + if (this.isZero() || other.isZero()) { + return this.field.zero; + } + var aCoefficients = this.coefficients; + var aLength = aCoefficients.length; + var bCoefficients = other.coefficients; + var bLength = bCoefficients.length; + var product = new Array(aLength + bLength - 1); + for (var i = 0; i < aLength; i++) { + var aCoeff = aCoefficients[i]; + for (var j = 0; j < bLength; j++) { + product[i + j] = GenericGF.addOrSubtract(product[i + j], this.field.multiply(aCoeff, bCoefficients[j])); + } + } + return new GenericGFPoly(this.field, product); + }; + GenericGFPoly.prototype.multiplyByMonomial = function (degree, coefficient) { + if (degree < 0) { + throw new Error("Invalid degree less than 0"); + } + if (coefficient == 0) { + return this.field.zero; + } + var size = this.coefficients.length; + var product = new Array(size + degree); + for (var i = 0; i < size; i++) { + product[i] = this.field.multiply(this.coefficients[i], coefficient); + } + return new GenericGFPoly(this.field, product); + }; + return GenericGFPoly; + }()); + var GenericGF = (function () { + function GenericGF(primitive, size, genBase) { + // ok. + this.INITIALIZATION_THRESHOLD = 0; + this.initialized = false; + this.primitive = primitive; + this.size = size; + this.generatorBase = genBase; + if (size <= this.INITIALIZATION_THRESHOLD) { + this.initialize(); + } + } + GenericGF.prototype.initialize = function () { + this.expTable = new Array(this.size); + this.logTable = new Array(this.size); + var x = 1; + for (var i = 0; i < this.size; i++) { + this.expTable[i] = x; + x <<= 1; // x = x * 2; we're assuming the generator alpha is 2 + if (x >= this.size) { + x ^= this.primitive; + x &= this.size - 1; + } + } + for (var i = 0; i < this.size - 1; i++) { + this.logTable[this.expTable[i]] = i; + } + // logTable[0] == 0 but this should never be used + this.zero = new GenericGFPoly(this, [0]); + this.one = new GenericGFPoly(this, [1]); + this.initialized = true; + }; + GenericGF.addOrSubtract = function (a, b) { + return a ^ b; + }; + GenericGF.prototype.checkInit = function () { + if (!this.initialized) + this.initialize(); + }; + GenericGF.prototype.multiply = function (a, b) { + this.checkInit(); + if (a == 0 || b == 0) { + return 0; + } + return this.expTable[(this.logTable[a] + this.logTable[b]) % (this.size - 1)]; + }; + GenericGF.prototype.exp = function (a) { + this.checkInit(); + return this.expTable[a]; + }; + GenericGF.prototype.log = function (a) { + this.checkInit(); + if (a == 0) { + throw new Error("Can't take log(0)"); + } + return this.logTable[a]; + }; + GenericGF.prototype.inverse = function (a) { + this.checkInit(); + if (a == 0) { + throw new Error("Can't invert 0"); + } + return this.expTable[this.size - this.logTable[a] - 1]; + }; + GenericGF.prototype.buildMonomial = function (degree, coefficient) { + this.checkInit(); + if (degree < 0) { + throw new Error("Invalid monomial degree less than 0"); + } + if (coefficient == 0) { + return this.zero; + } + var coefficients = new Array(degree + 1); + coefficients[0] = coefficient; + return new GenericGFPoly(this, coefficients); + }; + return GenericGF; + }()); /***/ } /******/ ]) }); ; -},{}],62:[function(require,module,exports){ +},{}],75:[function(require,module,exports){ (function (global){ /** * @license @@ -35490,7 +45282,7 @@ return /******/ (function(modules) { // webpackBootstrap }.call(this)); }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{}],63:[function(require,module,exports){ +},{}],76:[function(require,module,exports){ (function (process){ var path = require('path'); var fs = require('fs'); @@ -35602,357 +45394,357 @@ mime.charsets = { module.exports = mime; }).call(this,require('_process')) -},{"./types.json":64,"_process":98,"fs":42,"path":75}],64:[function(require,module,exports){ +},{"./types.json":77,"_process":117,"fs":47,"path":95}],77:[function(require,module,exports){ module.exports={"application/andrew-inset":["ez"],"application/applixware":["aw"],"application/atom+xml":["atom"],"application/atomcat+xml":["atomcat"],"application/atomsvc+xml":["atomsvc"],"application/bdoc":["bdoc"],"application/ccxml+xml":["ccxml"],"application/cdmi-capability":["cdmia"],"application/cdmi-container":["cdmic"],"application/cdmi-domain":["cdmid"],"application/cdmi-object":["cdmio"],"application/cdmi-queue":["cdmiq"],"application/cu-seeme":["cu"],"application/dash+xml":["mpd"],"application/davmount+xml":["davmount"],"application/docbook+xml":["dbk"],"application/dssc+der":["dssc"],"application/dssc+xml":["xdssc"],"application/ecmascript":["ecma"],"application/emma+xml":["emma"],"application/epub+zip":["epub"],"application/exi":["exi"],"application/font-tdpfr":["pfr"],"application/font-woff":[],"application/font-woff2":[],"application/geo+json":["geojson"],"application/gml+xml":["gml"],"application/gpx+xml":["gpx"],"application/gxf":["gxf"],"application/gzip":["gz"],"application/hyperstudio":["stk"],"application/inkml+xml":["ink","inkml"],"application/ipfix":["ipfix"],"application/java-archive":["jar","war","ear"],"application/java-serialized-object":["ser"],"application/java-vm":["class"],"application/javascript":["js","mjs"],"application/json":["json","map"],"application/json5":["json5"],"application/jsonml+json":["jsonml"],"application/ld+json":["jsonld"],"application/lost+xml":["lostxml"],"application/mac-binhex40":["hqx"],"application/mac-compactpro":["cpt"],"application/mads+xml":["mads"],"application/manifest+json":["webmanifest"],"application/marc":["mrc"],"application/marcxml+xml":["mrcx"],"application/mathematica":["ma","nb","mb"],"application/mathml+xml":["mathml"],"application/mbox":["mbox"],"application/mediaservercontrol+xml":["mscml"],"application/metalink+xml":["metalink"],"application/metalink4+xml":["meta4"],"application/mets+xml":["mets"],"application/mods+xml":["mods"],"application/mp21":["m21","mp21"],"application/mp4":["mp4s","m4p"],"application/msword":["doc","dot"],"application/mxf":["mxf"],"application/octet-stream":["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","exe","dll","deb","dmg","iso","img","msi","msp","msm","buffer"],"application/oda":["oda"],"application/oebps-package+xml":["opf"],"application/ogg":["ogx"],"application/omdoc+xml":["omdoc"],"application/onenote":["onetoc","onetoc2","onetmp","onepkg"],"application/oxps":["oxps"],"application/patch-ops-error+xml":["xer"],"application/pdf":["pdf"],"application/pgp-encrypted":["pgp"],"application/pgp-signature":["asc","sig"],"application/pics-rules":["prf"],"application/pkcs10":["p10"],"application/pkcs7-mime":["p7m","p7c"],"application/pkcs7-signature":["p7s"],"application/pkcs8":["p8"],"application/pkix-attr-cert":["ac"],"application/pkix-cert":["cer"],"application/pkix-crl":["crl"],"application/pkix-pkipath":["pkipath"],"application/pkixcmp":["pki"],"application/pls+xml":["pls"],"application/postscript":["ai","eps","ps"],"application/prs.cww":["cww"],"application/pskc+xml":["pskcxml"],"application/raml+yaml":["raml"],"application/rdf+xml":["rdf"],"application/reginfo+xml":["rif"],"application/relax-ng-compact-syntax":["rnc"],"application/resource-lists+xml":["rl"],"application/resource-lists-diff+xml":["rld"],"application/rls-services+xml":["rs"],"application/rpki-ghostbusters":["gbr"],"application/rpki-manifest":["mft"],"application/rpki-roa":["roa"],"application/rsd+xml":["rsd"],"application/rss+xml":["rss"],"application/rtf":["rtf"],"application/sbml+xml":["sbml"],"application/scvp-cv-request":["scq"],"application/scvp-cv-response":["scs"],"application/scvp-vp-request":["spq"],"application/scvp-vp-response":["spp"],"application/sdp":["sdp"],"application/set-payment-initiation":["setpay"],"application/set-registration-initiation":["setreg"],"application/shf+xml":["shf"],"application/smil+xml":["smi","smil"],"application/sparql-query":["rq"],"application/sparql-results+xml":["srx"],"application/srgs":["gram"],"application/srgs+xml":["grxml"],"application/sru+xml":["sru"],"application/ssdl+xml":["ssdl"],"application/ssml+xml":["ssml"],"application/tei+xml":["tei","teicorpus"],"application/thraud+xml":["tfi"],"application/timestamped-data":["tsd"],"application/vnd.3gpp.pic-bw-large":["plb"],"application/vnd.3gpp.pic-bw-small":["psb"],"application/vnd.3gpp.pic-bw-var":["pvb"],"application/vnd.3gpp2.tcap":["tcap"],"application/vnd.3m.post-it-notes":["pwn"],"application/vnd.accpac.simply.aso":["aso"],"application/vnd.accpac.simply.imp":["imp"],"application/vnd.acucobol":["acu"],"application/vnd.acucorp":["atc","acutc"],"application/vnd.adobe.air-application-installer-package+zip":["air"],"application/vnd.adobe.formscentral.fcdt":["fcdt"],"application/vnd.adobe.fxp":["fxp","fxpl"],"application/vnd.adobe.xdp+xml":["xdp"],"application/vnd.adobe.xfdf":["xfdf"],"application/vnd.ahead.space":["ahead"],"application/vnd.airzip.filesecure.azf":["azf"],"application/vnd.airzip.filesecure.azs":["azs"],"application/vnd.amazon.ebook":["azw"],"application/vnd.americandynamics.acc":["acc"],"application/vnd.amiga.ami":["ami"],"application/vnd.android.package-archive":["apk"],"application/vnd.anser-web-certificate-issue-initiation":["cii"],"application/vnd.anser-web-funds-transfer-initiation":["fti"],"application/vnd.antix.game-component":["atx"],"application/vnd.apple.installer+xml":["mpkg"],"application/vnd.apple.mpegurl":["m3u8"],"application/vnd.apple.pkpass":["pkpass"],"application/vnd.aristanetworks.swi":["swi"],"application/vnd.astraea-software.iota":["iota"],"application/vnd.audiograph":["aep"],"application/vnd.blueice.multipass":["mpm"],"application/vnd.bmi":["bmi"],"application/vnd.businessobjects":["rep"],"application/vnd.chemdraw+xml":["cdxml"],"application/vnd.chipnuts.karaoke-mmd":["mmd"],"application/vnd.cinderella":["cdy"],"application/vnd.claymore":["cla"],"application/vnd.cloanto.rp9":["rp9"],"application/vnd.clonk.c4group":["c4g","c4d","c4f","c4p","c4u"],"application/vnd.cluetrust.cartomobile-config":["c11amc"],"application/vnd.cluetrust.cartomobile-config-pkg":["c11amz"],"application/vnd.commonspace":["csp"],"application/vnd.contact.cmsg":["cdbcmsg"],"application/vnd.cosmocaller":["cmc"],"application/vnd.crick.clicker":["clkx"],"application/vnd.crick.clicker.keyboard":["clkk"],"application/vnd.crick.clicker.palette":["clkp"],"application/vnd.crick.clicker.template":["clkt"],"application/vnd.crick.clicker.wordbank":["clkw"],"application/vnd.criticaltools.wbs+xml":["wbs"],"application/vnd.ctc-posml":["pml"],"application/vnd.cups-ppd":["ppd"],"application/vnd.curl.car":["car"],"application/vnd.curl.pcurl":["pcurl"],"application/vnd.dart":["dart"],"application/vnd.data-vision.rdz":["rdz"],"application/vnd.dece.data":["uvf","uvvf","uvd","uvvd"],"application/vnd.dece.ttml+xml":["uvt","uvvt"],"application/vnd.dece.unspecified":["uvx","uvvx"],"application/vnd.dece.zip":["uvz","uvvz"],"application/vnd.denovo.fcselayout-link":["fe_launch"],"application/vnd.dna":["dna"],"application/vnd.dolby.mlp":["mlp"],"application/vnd.dpgraph":["dpg"],"application/vnd.dreamfactory":["dfac"],"application/vnd.ds-keypoint":["kpxx"],"application/vnd.dvb.ait":["ait"],"application/vnd.dvb.service":["svc"],"application/vnd.dynageo":["geo"],"application/vnd.ecowin.chart":["mag"],"application/vnd.enliven":["nml"],"application/vnd.epson.esf":["esf"],"application/vnd.epson.msf":["msf"],"application/vnd.epson.quickanime":["qam"],"application/vnd.epson.salt":["slt"],"application/vnd.epson.ssf":["ssf"],"application/vnd.eszigno3+xml":["es3","et3"],"application/vnd.ezpix-album":["ez2"],"application/vnd.ezpix-package":["ez3"],"application/vnd.fdf":["fdf"],"application/vnd.fdsn.mseed":["mseed"],"application/vnd.fdsn.seed":["seed","dataless"],"application/vnd.flographit":["gph"],"application/vnd.fluxtime.clip":["ftc"],"application/vnd.framemaker":["fm","frame","maker","book"],"application/vnd.frogans.fnc":["fnc"],"application/vnd.frogans.ltf":["ltf"],"application/vnd.fsc.weblaunch":["fsc"],"application/vnd.fujitsu.oasys":["oas"],"application/vnd.fujitsu.oasys2":["oa2"],"application/vnd.fujitsu.oasys3":["oa3"],"application/vnd.fujitsu.oasysgp":["fg5"],"application/vnd.fujitsu.oasysprs":["bh2"],"application/vnd.fujixerox.ddd":["ddd"],"application/vnd.fujixerox.docuworks":["xdw"],"application/vnd.fujixerox.docuworks.binder":["xbd"],"application/vnd.fuzzysheet":["fzs"],"application/vnd.genomatix.tuxedo":["txd"],"application/vnd.geogebra.file":["ggb"],"application/vnd.geogebra.tool":["ggt"],"application/vnd.geometry-explorer":["gex","gre"],"application/vnd.geonext":["gxt"],"application/vnd.geoplan":["g2w"],"application/vnd.geospace":["g3w"],"application/vnd.gmx":["gmx"],"application/vnd.google-apps.document":["gdoc"],"application/vnd.google-apps.presentation":["gslides"],"application/vnd.google-apps.spreadsheet":["gsheet"],"application/vnd.google-earth.kml+xml":["kml"],"application/vnd.google-earth.kmz":["kmz"],"application/vnd.grafeq":["gqf","gqs"],"application/vnd.groove-account":["gac"],"application/vnd.groove-help":["ghf"],"application/vnd.groove-identity-message":["gim"],"application/vnd.groove-injector":["grv"],"application/vnd.groove-tool-message":["gtm"],"application/vnd.groove-tool-template":["tpl"],"application/vnd.groove-vcard":["vcg"],"application/vnd.hal+xml":["hal"],"application/vnd.handheld-entertainment+xml":["zmm"],"application/vnd.hbci":["hbci"],"application/vnd.hhe.lesson-player":["les"],"application/vnd.hp-hpgl":["hpgl"],"application/vnd.hp-hpid":["hpid"],"application/vnd.hp-hps":["hps"],"application/vnd.hp-jlyt":["jlt"],"application/vnd.hp-pcl":["pcl"],"application/vnd.hp-pclxl":["pclxl"],"application/vnd.hydrostatix.sof-data":["sfd-hdstx"],"application/vnd.ibm.minipay":["mpy"],"application/vnd.ibm.modcap":["afp","listafp","list3820"],"application/vnd.ibm.rights-management":["irm"],"application/vnd.ibm.secure-container":["sc"],"application/vnd.iccprofile":["icc","icm"],"application/vnd.igloader":["igl"],"application/vnd.immervision-ivp":["ivp"],"application/vnd.immervision-ivu":["ivu"],"application/vnd.insors.igm":["igm"],"application/vnd.intercon.formnet":["xpw","xpx"],"application/vnd.intergeo":["i2g"],"application/vnd.intu.qbo":["qbo"],"application/vnd.intu.qfx":["qfx"],"application/vnd.ipunplugged.rcprofile":["rcprofile"],"application/vnd.irepository.package+xml":["irp"],"application/vnd.is-xpr":["xpr"],"application/vnd.isac.fcs":["fcs"],"application/vnd.jam":["jam"],"application/vnd.jcp.javame.midlet-rms":["rms"],"application/vnd.jisp":["jisp"],"application/vnd.joost.joda-archive":["joda"],"application/vnd.kahootz":["ktz","ktr"],"application/vnd.kde.karbon":["karbon"],"application/vnd.kde.kchart":["chrt"],"application/vnd.kde.kformula":["kfo"],"application/vnd.kde.kivio":["flw"],"application/vnd.kde.kontour":["kon"],"application/vnd.kde.kpresenter":["kpr","kpt"],"application/vnd.kde.kspread":["ksp"],"application/vnd.kde.kword":["kwd","kwt"],"application/vnd.kenameaapp":["htke"],"application/vnd.kidspiration":["kia"],"application/vnd.kinar":["kne","knp"],"application/vnd.koan":["skp","skd","skt","skm"],"application/vnd.kodak-descriptor":["sse"],"application/vnd.las.las+xml":["lasxml"],"application/vnd.llamagraphics.life-balance.desktop":["lbd"],"application/vnd.llamagraphics.life-balance.exchange+xml":["lbe"],"application/vnd.lotus-1-2-3":["123"],"application/vnd.lotus-approach":["apr"],"application/vnd.lotus-freelance":["pre"],"application/vnd.lotus-notes":["nsf"],"application/vnd.lotus-organizer":["org"],"application/vnd.lotus-screencam":["scm"],"application/vnd.lotus-wordpro":["lwp"],"application/vnd.macports.portpkg":["portpkg"],"application/vnd.mcd":["mcd"],"application/vnd.medcalcdata":["mc1"],"application/vnd.mediastation.cdkey":["cdkey"],"application/vnd.mfer":["mwf"],"application/vnd.mfmp":["mfm"],"application/vnd.micrografx.flo":["flo"],"application/vnd.micrografx.igx":["igx"],"application/vnd.mif":["mif"],"application/vnd.mobius.daf":["daf"],"application/vnd.mobius.dis":["dis"],"application/vnd.mobius.mbk":["mbk"],"application/vnd.mobius.mqy":["mqy"],"application/vnd.mobius.msl":["msl"],"application/vnd.mobius.plc":["plc"],"application/vnd.mobius.txf":["txf"],"application/vnd.mophun.application":["mpn"],"application/vnd.mophun.certificate":["mpc"],"application/vnd.mozilla.xul+xml":["xul"],"application/vnd.ms-artgalry":["cil"],"application/vnd.ms-cab-compressed":["cab"],"application/vnd.ms-excel":["xls","xlm","xla","xlc","xlt","xlw"],"application/vnd.ms-excel.addin.macroenabled.12":["xlam"],"application/vnd.ms-excel.sheet.binary.macroenabled.12":["xlsb"],"application/vnd.ms-excel.sheet.macroenabled.12":["xlsm"],"application/vnd.ms-excel.template.macroenabled.12":["xltm"],"application/vnd.ms-fontobject":["eot"],"application/vnd.ms-htmlhelp":["chm"],"application/vnd.ms-ims":["ims"],"application/vnd.ms-lrm":["lrm"],"application/vnd.ms-officetheme":["thmx"],"application/vnd.ms-outlook":["msg"],"application/vnd.ms-pki.seccat":["cat"],"application/vnd.ms-pki.stl":["stl"],"application/vnd.ms-powerpoint":["ppt","pps","pot"],"application/vnd.ms-powerpoint.addin.macroenabled.12":["ppam"],"application/vnd.ms-powerpoint.presentation.macroenabled.12":["pptm"],"application/vnd.ms-powerpoint.slide.macroenabled.12":["sldm"],"application/vnd.ms-powerpoint.slideshow.macroenabled.12":["ppsm"],"application/vnd.ms-powerpoint.template.macroenabled.12":["potm"],"application/vnd.ms-project":["mpp","mpt"],"application/vnd.ms-word.document.macroenabled.12":["docm"],"application/vnd.ms-word.template.macroenabled.12":["dotm"],"application/vnd.ms-works":["wps","wks","wcm","wdb"],"application/vnd.ms-wpl":["wpl"],"application/vnd.ms-xpsdocument":["xps"],"application/vnd.mseq":["mseq"],"application/vnd.musician":["mus"],"application/vnd.muvee.style":["msty"],"application/vnd.mynfc":["taglet"],"application/vnd.neurolanguage.nlu":["nlu"],"application/vnd.nitf":["ntf","nitf"],"application/vnd.noblenet-directory":["nnd"],"application/vnd.noblenet-sealer":["nns"],"application/vnd.noblenet-web":["nnw"],"application/vnd.nokia.n-gage.data":["ngdat"],"application/vnd.nokia.n-gage.symbian.install":["n-gage"],"application/vnd.nokia.radio-preset":["rpst"],"application/vnd.nokia.radio-presets":["rpss"],"application/vnd.novadigm.edm":["edm"],"application/vnd.novadigm.edx":["edx"],"application/vnd.novadigm.ext":["ext"],"application/vnd.oasis.opendocument.chart":["odc"],"application/vnd.oasis.opendocument.chart-template":["otc"],"application/vnd.oasis.opendocument.database":["odb"],"application/vnd.oasis.opendocument.formula":["odf"],"application/vnd.oasis.opendocument.formula-template":["odft"],"application/vnd.oasis.opendocument.graphics":["odg"],"application/vnd.oasis.opendocument.graphics-template":["otg"],"application/vnd.oasis.opendocument.image":["odi"],"application/vnd.oasis.opendocument.image-template":["oti"],"application/vnd.oasis.opendocument.presentation":["odp"],"application/vnd.oasis.opendocument.presentation-template":["otp"],"application/vnd.oasis.opendocument.spreadsheet":["ods"],"application/vnd.oasis.opendocument.spreadsheet-template":["ots"],"application/vnd.oasis.opendocument.text":["odt"],"application/vnd.oasis.opendocument.text-master":["odm"],"application/vnd.oasis.opendocument.text-template":["ott"],"application/vnd.oasis.opendocument.text-web":["oth"],"application/vnd.olpc-sugar":["xo"],"application/vnd.oma.dd2+xml":["dd2"],"application/vnd.openofficeorg.extension":["oxt"],"application/vnd.openxmlformats-officedocument.presentationml.presentation":["pptx"],"application/vnd.openxmlformats-officedocument.presentationml.slide":["sldx"],"application/vnd.openxmlformats-officedocument.presentationml.slideshow":["ppsx"],"application/vnd.openxmlformats-officedocument.presentationml.template":["potx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":["xlsx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.template":["xltx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.document":["docx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.template":["dotx"],"application/vnd.osgeo.mapguide.package":["mgp"],"application/vnd.osgi.dp":["dp"],"application/vnd.osgi.subsystem":["esa"],"application/vnd.palm":["pdb","pqa","oprc"],"application/vnd.pawaafile":["paw"],"application/vnd.pg.format":["str"],"application/vnd.pg.osasli":["ei6"],"application/vnd.picsel":["efif"],"application/vnd.pmi.widget":["wg"],"application/vnd.pocketlearn":["plf"],"application/vnd.powerbuilder6":["pbd"],"application/vnd.previewsystems.box":["box"],"application/vnd.proteus.magazine":["mgz"],"application/vnd.publishare-delta-tree":["qps"],"application/vnd.pvi.ptid1":["ptid"],"application/vnd.quark.quarkxpress":["qxd","qxt","qwd","qwt","qxl","qxb"],"application/vnd.realvnc.bed":["bed"],"application/vnd.recordare.musicxml":["mxl"],"application/vnd.recordare.musicxml+xml":["musicxml"],"application/vnd.rig.cryptonote":["cryptonote"],"application/vnd.rim.cod":["cod"],"application/vnd.rn-realmedia":["rm"],"application/vnd.rn-realmedia-vbr":["rmvb"],"application/vnd.route66.link66+xml":["link66"],"application/vnd.sailingtracker.track":["st"],"application/vnd.seemail":["see"],"application/vnd.sema":["sema"],"application/vnd.semd":["semd"],"application/vnd.semf":["semf"],"application/vnd.shana.informed.formdata":["ifm"],"application/vnd.shana.informed.formtemplate":["itp"],"application/vnd.shana.informed.interchange":["iif"],"application/vnd.shana.informed.package":["ipk"],"application/vnd.simtech-mindmapper":["twd","twds"],"application/vnd.smaf":["mmf"],"application/vnd.smart.teacher":["teacher"],"application/vnd.solent.sdkm+xml":["sdkm","sdkd"],"application/vnd.spotfire.dxp":["dxp"],"application/vnd.spotfire.sfs":["sfs"],"application/vnd.stardivision.calc":["sdc"],"application/vnd.stardivision.draw":["sda"],"application/vnd.stardivision.impress":["sdd"],"application/vnd.stardivision.math":["smf"],"application/vnd.stardivision.writer":["sdw","vor"],"application/vnd.stardivision.writer-global":["sgl"],"application/vnd.stepmania.package":["smzip"],"application/vnd.stepmania.stepchart":["sm"],"application/vnd.sun.wadl+xml":["wadl"],"application/vnd.sun.xml.calc":["sxc"],"application/vnd.sun.xml.calc.template":["stc"],"application/vnd.sun.xml.draw":["sxd"],"application/vnd.sun.xml.draw.template":["std"],"application/vnd.sun.xml.impress":["sxi"],"application/vnd.sun.xml.impress.template":["sti"],"application/vnd.sun.xml.math":["sxm"],"application/vnd.sun.xml.writer":["sxw"],"application/vnd.sun.xml.writer.global":["sxg"],"application/vnd.sun.xml.writer.template":["stw"],"application/vnd.sus-calendar":["sus","susp"],"application/vnd.svd":["svd"],"application/vnd.symbian.install":["sis","sisx"],"application/vnd.syncml+xml":["xsm"],"application/vnd.syncml.dm+wbxml":["bdm"],"application/vnd.syncml.dm+xml":["xdm"],"application/vnd.tao.intent-module-archive":["tao"],"application/vnd.tcpdump.pcap":["pcap","cap","dmp"],"application/vnd.tmobile-livetv":["tmo"],"application/vnd.trid.tpt":["tpt"],"application/vnd.triscape.mxs":["mxs"],"application/vnd.trueapp":["tra"],"application/vnd.ufdl":["ufd","ufdl"],"application/vnd.uiq.theme":["utz"],"application/vnd.umajin":["umj"],"application/vnd.unity":["unityweb"],"application/vnd.uoml+xml":["uoml"],"application/vnd.vcx":["vcx"],"application/vnd.visio":["vsd","vst","vss","vsw"],"application/vnd.visionary":["vis"],"application/vnd.vsf":["vsf"],"application/vnd.wap.wbxml":["wbxml"],"application/vnd.wap.wmlc":["wmlc"],"application/vnd.wap.wmlscriptc":["wmlsc"],"application/vnd.webturbo":["wtb"],"application/vnd.wolfram.player":["nbp"],"application/vnd.wordperfect":["wpd"],"application/vnd.wqd":["wqd"],"application/vnd.wt.stf":["stf"],"application/vnd.xara":["xar"],"application/vnd.xfdl":["xfdl"],"application/vnd.yamaha.hv-dic":["hvd"],"application/vnd.yamaha.hv-script":["hvs"],"application/vnd.yamaha.hv-voice":["hvp"],"application/vnd.yamaha.openscoreformat":["osf"],"application/vnd.yamaha.openscoreformat.osfpvg+xml":["osfpvg"],"application/vnd.yamaha.smaf-audio":["saf"],"application/vnd.yamaha.smaf-phrase":["spf"],"application/vnd.yellowriver-custom-menu":["cmp"],"application/vnd.zul":["zir","zirz"],"application/vnd.zzazz.deck+xml":["zaz"],"application/voicexml+xml":["vxml"],"application/wasm":["wasm"],"application/widget":["wgt"],"application/winhlp":["hlp"],"application/wsdl+xml":["wsdl"],"application/wspolicy+xml":["wspolicy"],"application/x-7z-compressed":["7z"],"application/x-abiword":["abw"],"application/x-ace-compressed":["ace"],"application/x-apple-diskimage":[],"application/x-arj":["arj"],"application/x-authorware-bin":["aab","x32","u32","vox"],"application/x-authorware-map":["aam"],"application/x-authorware-seg":["aas"],"application/x-bcpio":["bcpio"],"application/x-bdoc":[],"application/x-bittorrent":["torrent"],"application/x-blorb":["blb","blorb"],"application/x-bzip":["bz"],"application/x-bzip2":["bz2","boz"],"application/x-cbr":["cbr","cba","cbt","cbz","cb7"],"application/x-cdlink":["vcd"],"application/x-cfs-compressed":["cfs"],"application/x-chat":["chat"],"application/x-chess-pgn":["pgn"],"application/x-chrome-extension":["crx"],"application/x-cocoa":["cco"],"application/x-conference":["nsc"],"application/x-cpio":["cpio"],"application/x-csh":["csh"],"application/x-debian-package":["udeb"],"application/x-dgc-compressed":["dgc"],"application/x-director":["dir","dcr","dxr","cst","cct","cxt","w3d","fgd","swa"],"application/x-doom":["wad"],"application/x-dtbncx+xml":["ncx"],"application/x-dtbook+xml":["dtb"],"application/x-dtbresource+xml":["res"],"application/x-dvi":["dvi"],"application/x-envoy":["evy"],"application/x-eva":["eva"],"application/x-font-bdf":["bdf"],"application/x-font-ghostscript":["gsf"],"application/x-font-linux-psf":["psf"],"application/x-font-pcf":["pcf"],"application/x-font-snf":["snf"],"application/x-font-type1":["pfa","pfb","pfm","afm"],"application/x-freearc":["arc"],"application/x-futuresplash":["spl"],"application/x-gca-compressed":["gca"],"application/x-glulx":["ulx"],"application/x-gnumeric":["gnumeric"],"application/x-gramps-xml":["gramps"],"application/x-gtar":["gtar"],"application/x-hdf":["hdf"],"application/x-httpd-php":["php"],"application/x-install-instructions":["install"],"application/x-iso9660-image":[],"application/x-java-archive-diff":["jardiff"],"application/x-java-jnlp-file":["jnlp"],"application/x-latex":["latex"],"application/x-lua-bytecode":["luac"],"application/x-lzh-compressed":["lzh","lha"],"application/x-makeself":["run"],"application/x-mie":["mie"],"application/x-mobipocket-ebook":["prc","mobi"],"application/x-ms-application":["application"],"application/x-ms-shortcut":["lnk"],"application/x-ms-wmd":["wmd"],"application/x-ms-wmz":["wmz"],"application/x-ms-xbap":["xbap"],"application/x-msaccess":["mdb"],"application/x-msbinder":["obd"],"application/x-mscardfile":["crd"],"application/x-msclip":["clp"],"application/x-msdos-program":[],"application/x-msdownload":["com","bat"],"application/x-msmediaview":["mvb","m13","m14"],"application/x-msmetafile":["wmf","emf","emz"],"application/x-msmoney":["mny"],"application/x-mspublisher":["pub"],"application/x-msschedule":["scd"],"application/x-msterminal":["trm"],"application/x-mswrite":["wri"],"application/x-netcdf":["nc","cdf"],"application/x-ns-proxy-autoconfig":["pac"],"application/x-nzb":["nzb"],"application/x-perl":["pl","pm"],"application/x-pilot":[],"application/x-pkcs12":["p12","pfx"],"application/x-pkcs7-certificates":["p7b","spc"],"application/x-pkcs7-certreqresp":["p7r"],"application/x-rar-compressed":["rar"],"application/x-redhat-package-manager":["rpm"],"application/x-research-info-systems":["ris"],"application/x-sea":["sea"],"application/x-sh":["sh"],"application/x-shar":["shar"],"application/x-shockwave-flash":["swf"],"application/x-silverlight-app":["xap"],"application/x-sql":["sql"],"application/x-stuffit":["sit"],"application/x-stuffitx":["sitx"],"application/x-subrip":["srt"],"application/x-sv4cpio":["sv4cpio"],"application/x-sv4crc":["sv4crc"],"application/x-t3vm-image":["t3"],"application/x-tads":["gam"],"application/x-tar":["tar"],"application/x-tcl":["tcl","tk"],"application/x-tex":["tex"],"application/x-tex-tfm":["tfm"],"application/x-texinfo":["texinfo","texi"],"application/x-tgif":["obj"],"application/x-ustar":["ustar"],"application/x-virtualbox-hdd":["hdd"],"application/x-virtualbox-ova":["ova"],"application/x-virtualbox-ovf":["ovf"],"application/x-virtualbox-vbox":["vbox"],"application/x-virtualbox-vbox-extpack":["vbox-extpack"],"application/x-virtualbox-vdi":["vdi"],"application/x-virtualbox-vhd":["vhd"],"application/x-virtualbox-vmdk":["vmdk"],"application/x-wais-source":["src"],"application/x-web-app-manifest+json":["webapp"],"application/x-x509-ca-cert":["der","crt","pem"],"application/x-xfig":["fig"],"application/x-xliff+xml":["xlf"],"application/x-xpinstall":["xpi"],"application/x-xz":["xz"],"application/x-zmachine":["z1","z2","z3","z4","z5","z6","z7","z8"],"application/xaml+xml":["xaml"],"application/xcap-diff+xml":["xdf"],"application/xenc+xml":["xenc"],"application/xhtml+xml":["xhtml","xht"],"application/xml":["xml","xsl","xsd","rng"],"application/xml-dtd":["dtd"],"application/xop+xml":["xop"],"application/xproc+xml":["xpl"],"application/xslt+xml":["xslt"],"application/xspf+xml":["xspf"],"application/xv+xml":["mxml","xhvml","xvml","xvm"],"application/yang":["yang"],"application/yin+xml":["yin"],"application/zip":["zip"],"audio/3gpp":[],"audio/adpcm":["adp"],"audio/basic":["au","snd"],"audio/midi":["mid","midi","kar","rmi"],"audio/mp3":[],"audio/mp4":["m4a","mp4a"],"audio/mpeg":["mpga","mp2","mp2a","mp3","m2a","m3a"],"audio/ogg":["oga","ogg","spx"],"audio/s3m":["s3m"],"audio/silk":["sil"],"audio/vnd.dece.audio":["uva","uvva"],"audio/vnd.digital-winds":["eol"],"audio/vnd.dra":["dra"],"audio/vnd.dts":["dts"],"audio/vnd.dts.hd":["dtshd"],"audio/vnd.lucent.voice":["lvp"],"audio/vnd.ms-playready.media.pya":["pya"],"audio/vnd.nuera.ecelp4800":["ecelp4800"],"audio/vnd.nuera.ecelp7470":["ecelp7470"],"audio/vnd.nuera.ecelp9600":["ecelp9600"],"audio/vnd.rip":["rip"],"audio/wav":["wav"],"audio/wave":[],"audio/webm":["weba"],"audio/x-aac":["aac"],"audio/x-aiff":["aif","aiff","aifc"],"audio/x-caf":["caf"],"audio/x-flac":["flac"],"audio/x-m4a":[],"audio/x-matroska":["mka"],"audio/x-mpegurl":["m3u"],"audio/x-ms-wax":["wax"],"audio/x-ms-wma":["wma"],"audio/x-pn-realaudio":["ram","ra"],"audio/x-pn-realaudio-plugin":["rmp"],"audio/x-realaudio":[],"audio/x-wav":[],"audio/xm":["xm"],"chemical/x-cdx":["cdx"],"chemical/x-cif":["cif"],"chemical/x-cmdf":["cmdf"],"chemical/x-cml":["cml"],"chemical/x-csml":["csml"],"chemical/x-xyz":["xyz"],"font/collection":["ttc"],"font/otf":["otf"],"font/ttf":["ttf"],"font/woff":["woff"],"font/woff2":["woff2"],"image/apng":["apng"],"image/bmp":["bmp"],"image/cgm":["cgm"],"image/g3fax":["g3"],"image/gif":["gif"],"image/ief":["ief"],"image/jp2":["jp2","jpg2"],"image/jpeg":["jpeg","jpg","jpe"],"image/jpm":["jpm"],"image/jpx":["jpx","jpf"],"image/ktx":["ktx"],"image/png":["png"],"image/prs.btif":["btif"],"image/sgi":["sgi"],"image/svg+xml":["svg","svgz"],"image/tiff":["tiff","tif"],"image/vnd.adobe.photoshop":["psd"],"image/vnd.dece.graphic":["uvi","uvvi","uvg","uvvg"],"image/vnd.djvu":["djvu","djv"],"image/vnd.dvb.subtitle":[],"image/vnd.dwg":["dwg"],"image/vnd.dxf":["dxf"],"image/vnd.fastbidsheet":["fbs"],"image/vnd.fpx":["fpx"],"image/vnd.fst":["fst"],"image/vnd.fujixerox.edmics-mmr":["mmr"],"image/vnd.fujixerox.edmics-rlc":["rlc"],"image/vnd.ms-modi":["mdi"],"image/vnd.ms-photo":["wdp"],"image/vnd.net-fpx":["npx"],"image/vnd.wap.wbmp":["wbmp"],"image/vnd.xiff":["xif"],"image/webp":["webp"],"image/x-3ds":["3ds"],"image/x-cmu-raster":["ras"],"image/x-cmx":["cmx"],"image/x-freehand":["fh","fhc","fh4","fh5","fh7"],"image/x-icon":["ico"],"image/x-jng":["jng"],"image/x-mrsid-image":["sid"],"image/x-ms-bmp":[],"image/x-pcx":["pcx"],"image/x-pict":["pic","pct"],"image/x-portable-anymap":["pnm"],"image/x-portable-bitmap":["pbm"],"image/x-portable-graymap":["pgm"],"image/x-portable-pixmap":["ppm"],"image/x-rgb":["rgb"],"image/x-tga":["tga"],"image/x-xbitmap":["xbm"],"image/x-xpixmap":["xpm"],"image/x-xwindowdump":["xwd"],"message/rfc822":["eml","mime"],"model/gltf+json":["gltf"],"model/gltf-binary":["glb"],"model/iges":["igs","iges"],"model/mesh":["msh","mesh","silo"],"model/vnd.collada+xml":["dae"],"model/vnd.dwf":["dwf"],"model/vnd.gdl":["gdl"],"model/vnd.gtw":["gtw"],"model/vnd.mts":["mts"],"model/vnd.vtu":["vtu"],"model/vrml":["wrl","vrml"],"model/x3d+binary":["x3db","x3dbz"],"model/x3d+vrml":["x3dv","x3dvz"],"model/x3d+xml":["x3d","x3dz"],"text/cache-manifest":["appcache","manifest"],"text/calendar":["ics","ifb"],"text/coffeescript":["coffee","litcoffee"],"text/css":["css"],"text/csv":["csv"],"text/hjson":["hjson"],"text/html":["html","htm","shtml"],"text/jade":["jade"],"text/jsx":["jsx"],"text/less":["less"],"text/markdown":["markdown","md"],"text/mathml":["mml"],"text/n3":["n3"],"text/plain":["txt","text","conf","def","list","log","in","ini"],"text/prs.lines.tag":["dsc"],"text/richtext":["rtx"],"text/rtf":[],"text/sgml":["sgml","sgm"],"text/slim":["slim","slm"],"text/stylus":["stylus","styl"],"text/tab-separated-values":["tsv"],"text/troff":["t","tr","roff","man","me","ms"],"text/turtle":["ttl"],"text/uri-list":["uri","uris","urls"],"text/vcard":["vcard"],"text/vnd.curl":["curl"],"text/vnd.curl.dcurl":["dcurl"],"text/vnd.curl.mcurl":["mcurl"],"text/vnd.curl.scurl":["scurl"],"text/vnd.dvb.subtitle":["sub"],"text/vnd.fly":["fly"],"text/vnd.fmi.flexstor":["flx"],"text/vnd.graphviz":["gv"],"text/vnd.in3d.3dml":["3dml"],"text/vnd.in3d.spot":["spot"],"text/vnd.sun.j2me.app-descriptor":["jad"],"text/vnd.wap.wml":["wml"],"text/vnd.wap.wmlscript":["wmls"],"text/vtt":["vtt"],"text/x-asm":["s","asm"],"text/x-c":["c","cc","cxx","cpp","h","hh","dic"],"text/x-component":["htc"],"text/x-fortran":["f","for","f77","f90"],"text/x-handlebars-template":["hbs"],"text/x-java-source":["java"],"text/x-lua":["lua"],"text/x-markdown":["mkd"],"text/x-nfo":["nfo"],"text/x-opml":["opml"],"text/x-org":[],"text/x-pascal":["p","pas"],"text/x-processing":["pde"],"text/x-sass":["sass"],"text/x-scss":["scss"],"text/x-setext":["etx"],"text/x-sfv":["sfv"],"text/x-suse-ymp":["ymp"],"text/x-uuencode":["uu"],"text/x-vcalendar":["vcs"],"text/x-vcard":["vcf"],"text/xml":[],"text/yaml":["yaml","yml"],"video/3gpp":["3gp","3gpp"],"video/3gpp2":["3g2"],"video/h261":["h261"],"video/h263":["h263"],"video/h264":["h264"],"video/jpeg":["jpgv"],"video/jpm":["jpgm"],"video/mj2":["mj2","mjp2"],"video/mp2t":["ts"],"video/mp4":["mp4","mp4v","mpg4"],"video/mpeg":["mpeg","mpg","mpe","m1v","m2v"],"video/ogg":["ogv"],"video/quicktime":["qt","mov"],"video/vnd.dece.hd":["uvh","uvvh"],"video/vnd.dece.mobile":["uvm","uvvm"],"video/vnd.dece.pd":["uvp","uvvp"],"video/vnd.dece.sd":["uvs","uvvs"],"video/vnd.dece.video":["uvv","uvvv"],"video/vnd.dvb.file":["dvb"],"video/vnd.fvt":["fvt"],"video/vnd.mpegurl":["mxu","m4u"],"video/vnd.ms-playready.media.pyv":["pyv"],"video/vnd.uvvu.mp4":["uvu","uvvu"],"video/vnd.vivo":["viv"],"video/webm":["webm"],"video/x-f4v":["f4v"],"video/x-fli":["fli"],"video/x-flv":["flv"],"video/x-m4v":["m4v"],"video/x-matroska":["mkv","mk3d","mks"],"video/x-mng":["mng"],"video/x-ms-asf":["asf","asx"],"video/x-ms-vob":["vob"],"video/x-ms-wm":["wm"],"video/x-ms-wmv":["wmv"],"video/x-ms-wmx":["wmx"],"video/x-ms-wvx":["wvx"],"video/x-msvideo":["avi"],"video/x-sgi-movie":["movie"],"video/x-smv":["smv"],"x-conference/x-cooltalk":["ice"]} -},{}],65:[function(require,module,exports){ -'use strict' - -var ops = require('ndarray-ops') -var ndarray = require('ndarray') -var pool = require('typedarray-pool') -var fftm = require('./lib/fft-matrix.js') - -function ndfft(dir, x, y) { - var shape = x.shape - , d = shape.length - , size = 1 - , stride = new Array(d) - , pad = 0 - , i, j - for(i=d-1; i>=0; --i) { - stride[i] = size - size *= shape[i] - pad = Math.max(pad, fftm.scratchMemory(shape[i])) - if(x.shape[i] !== y.shape[i]) { - throw new Error('Shape mismatch, real and imaginary arrays must have same size') - } - } - var buf_size = 4 * size + pad - var buffer - if( x.dtype === 'array' || - x.dtype === 'float64' || - x.dtype === 'custom' ) { - buffer = pool.mallocDouble(buf_size) - } else { - buffer = pool.mallocFloat(buf_size) - } - var x1 = ndarray(buffer, shape.slice(0), stride, 0) - , y1 = ndarray(buffer, shape.slice(0), stride.slice(0), size) - , x2 = ndarray(buffer, shape.slice(0), stride.slice(0), 2*size) - , y2 = ndarray(buffer, shape.slice(0), stride.slice(0), 3*size) - , tmp, n, s1, s2 - , scratch_ptr = 4 * size - - //Copy into x1/y1 - ops.assign(x1, x) - ops.assign(y1, y) - - for(i=d-1; i>=0; --i) { - fftm(dir, size/shape[i], shape[i], buffer, x1.offset, y1.offset, scratch_ptr) - if(i === 0) { - break - } - - //Compute new stride for x2/y2 - n = 1 - s1 = x2.stride - s2 = y2.stride - for(j=i-1; j=0; --j) { - s2[j] = s1[j] = n - n *= shape[j] - } - - //Transpose - ops.assign(x2, x1) - ops.assign(y2, y1) - - //Swap buffers - tmp = x1 - x1 = x2 - x2 = tmp - tmp = y1 - y1 = y2 - y2 = tmp - } - - //Copy result back into x - ops.assign(x, x1) - ops.assign(y, y1) - - pool.free(buffer) -} - +},{}],78:[function(require,module,exports){ +'use strict' + +var ops = require('ndarray-ops') +var ndarray = require('ndarray') +var pool = require('typedarray-pool') +var fftm = require('./lib/fft-matrix.js') + +function ndfft(dir, x, y) { + var shape = x.shape + , d = shape.length + , size = 1 + , stride = new Array(d) + , pad = 0 + , i, j + for(i=d-1; i>=0; --i) { + stride[i] = size + size *= shape[i] + pad = Math.max(pad, fftm.scratchMemory(shape[i])) + if(x.shape[i] !== y.shape[i]) { + throw new Error('Shape mismatch, real and imaginary arrays must have same size') + } + } + var buf_size = 4 * size + pad + var buffer + if( x.dtype === 'array' || + x.dtype === 'float64' || + x.dtype === 'custom' ) { + buffer = pool.mallocDouble(buf_size) + } else { + buffer = pool.mallocFloat(buf_size) + } + var x1 = ndarray(buffer, shape.slice(0), stride, 0) + , y1 = ndarray(buffer, shape.slice(0), stride.slice(0), size) + , x2 = ndarray(buffer, shape.slice(0), stride.slice(0), 2*size) + , y2 = ndarray(buffer, shape.slice(0), stride.slice(0), 3*size) + , tmp, n, s1, s2 + , scratch_ptr = 4 * size + + //Copy into x1/y1 + ops.assign(x1, x) + ops.assign(y1, y) + + for(i=d-1; i>=0; --i) { + fftm(dir, size/shape[i], shape[i], buffer, x1.offset, y1.offset, scratch_ptr) + if(i === 0) { + break + } + + //Compute new stride for x2/y2 + n = 1 + s1 = x2.stride + s2 = y2.stride + for(j=i-1; j=0; --j) { + s2[j] = s1[j] = n + n *= shape[j] + } + + //Transpose + ops.assign(x2, x1) + ops.assign(y2, y1) + + //Swap buffers + tmp = x1 + x1 = x2 + x2 = tmp + tmp = y1 + y1 = y2 + y2 = tmp + } + + //Copy result back into x + ops.assign(x, x1) + ops.assign(y, y1) + + pool.free(buffer) +} + module.exports = ndfft -},{"./lib/fft-matrix.js":66,"ndarray":71,"ndarray-ops":68,"typedarray-pool":130}],66:[function(require,module,exports){ -var bits = require('bit-twiddle') +},{"./lib/fft-matrix.js":79,"ndarray":84,"ndarray-ops":81,"typedarray-pool":144}],79:[function(require,module,exports){ +var bits = require('bit-twiddle') + +function fft(dir, nrows, ncols, buffer, x_ptr, y_ptr, scratch_ptr) { + dir |= 0 + nrows |= 0 + ncols |= 0 + x_ptr |= 0 + y_ptr |= 0 + if(bits.isPow2(ncols)) { + fftRadix2(dir, nrows, ncols, buffer, x_ptr, y_ptr) + } else { + fftBluestein(dir, nrows, ncols, buffer, x_ptr, y_ptr, scratch_ptr) + } +} +module.exports = fft + +function scratchMemory(n) { + if(bits.isPow2(n)) { + return 0 + } + return 2 * n + 4 * bits.nextPow2(2*n + 1) +} +module.exports.scratchMemory = scratchMemory + + +//Radix 2 FFT Adapted from Paul Bourke's C Implementation +function fftRadix2(dir, nrows, ncols, buffer, x_ptr, y_ptr) { + dir |= 0 + nrows |= 0 + ncols |= 0 + x_ptr |= 0 + y_ptr |= 0 + var nn,m,i,i1,j,k,i2,l,l1,l2 + var c1,c2,t,t1,t2,u1,u2,z,row,a,b,c,d,k1,k2,k3 + + // Calculate the number of points + nn = ncols + m = bits.log2(nn) + + for(row=0; row> 1; + j = 0; + for(i=0;i>= 1 + } + j += k + } + + // Compute the FFT + c1 = -1.0 + c2 = 0.0 + l2 = 1 + for(l=0;l> 1; - j = 0; - for(i=0;i>= 1 - } - j += k - } - - // Compute the FFT - c1 = -1.0 - c2 = 0.0 - l2 = 1 - for(l=0;l 0) { + this._paused = false; + + this.emit('drain'); + } + }.bind(this)); +}; + +ChunkStream.prototype.write = function(data, encoding) { + + if (!this.writable) { + this.emit('error', new Error('Stream not writable')); + return false; + } + + if (!Buffer.isBuffer(data)) + data = new Buffer(data, encoding || this._encoding); + + this._buffers.push(data); + this._buffered += data.length; + + this._process(); + + // ok if there are no more read requests + if (this._reads && this._reads.length == 0) + this._paused = true; + + return this.writable && !this._paused; +}; + +ChunkStream.prototype.end = function(data, encoding) { + + if (data) this.write(data, encoding); + + this.writable = false; + + // already destroyed + if (!this._buffers) return; + + // enqueue or handle end + if (this._buffers.length == 0) { + this._end(); + } else { + this._buffers.push(null); + this._process(); + } +}; + +ChunkStream.prototype.destroySoon = ChunkStream.prototype.end; + +ChunkStream.prototype._end = function() { + + if (this._reads.length > 0) { + this.emit('error', + new Error('There are some read requests waitng on finished stream') + ); + } + + this.destroy(); +}; + +ChunkStream.prototype.destroy = function() { + + if (!this._buffers) return; + + this.writable = false; + this._reads = null; + this._buffers = null; + + this.emit('close'); +}; + +ChunkStream.prototype._process = function() { + + // as long as there is any data and read requests + while (this._buffered > 0 && this._reads && this._reads.length > 0) { + + var read = this._reads[0]; + + // read any data (but no more than length) + if (read.allowLess) { + + // ok there is any data so that we can satisfy this request + this._reads.shift(); // == read + + // first we need to peek into first buffer + var buf = this._buffers[0]; + + // ok there is more data than we need + if (buf.length > read.length) { + + this._buffered -= read.length; + this._buffers[0] = buf.slice(read.length); + + read.func.call(this, buf.slice(0, read.length)); + + } else { + // ok this is less than maximum length so use it all + this._buffered -= buf.length; + this._buffers.shift(); // == buf + + read.func.call(this, buf); + } + + } else if (this._buffered >= read.length) { + // ok we can meet some expectations + + this._reads.shift(); // == read + + var pos = 0, + count = 0, + data = new Buffer(read.length); + + // create buffer for all data + while (pos < read.length) { + + var buf = this._buffers[count++], + len = Math.min(buf.length, read.length - pos); + + buf.copy(data, pos, 0, len); + pos += len; + + // last buffer wasn't used all so just slice it and leave + if (len != buf.length) + this._buffers[--count] = buf.slice(len); + } + + // remove all used buffers + if (count > 0) + this._buffers.splice(0, count); + + this._buffered -= read.length; + + read.func.call(this, data); + + } else { + // not enought data to satisfy first request in queue + // so we need to wait for more + break; + } + } + + if (this._buffers && this._buffers.length > 0 && this._buffers[0] == null) { + this._end(); + } +}; + +}).call(this,require('_process'),require("buffer").Buffer) +},{"_process":117,"buffer":5,"stream":139,"util":150}],87:[function(require,module,exports){ +// Copyright (c) 2012 Kuba Niegowski +// +// 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. + +'use strict'; + + +module.exports = { + + PNG_SIGNATURE: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], + + TYPE_IHDR: 0x49484452, + TYPE_IEND: 0x49454e44, + TYPE_IDAT: 0x49444154, + TYPE_PLTE: 0x504c5445, + TYPE_tRNS: 0x74524e53, + TYPE_gAMA: 0x67414d41, + + COLOR_PALETTE: 1, + COLOR_COLOR: 2, + COLOR_ALPHA: 4 +}; + +},{}],88:[function(require,module,exports){ +// Copyright (c) 2012 Kuba Niegowski +// +// 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. + +'use strict'; + +var util = require('util'), + Stream = require('stream'); + + +var CrcStream = module.exports = function() { + Stream.call(this); + + this._crc = -1; + + this.writable = true; +}; +util.inherits(CrcStream, Stream); + + +CrcStream.prototype.write = function(data) { + + for (var i = 0; i < data.length; i++) { + this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8); + } + return true; +}; + +CrcStream.prototype.end = function(data) { + if (data) this.write(data); + + this.emit('crc', this.crc32()); +}; + +CrcStream.prototype.crc32 = function() { + return this._crc ^ -1; +}; + + +CrcStream.crc32 = function(buf) { + + var crc = -1; + for (var i = 0; i < buf.length; i++) { + crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8); + } + return crc ^ -1; +}; + + + +var crcTable = []; + +for (var i = 0; i < 256; i++) { + var c = i; + for (var j = 0; j < 8; j++) { + if (c & 1) { + c = 0xedb88320 ^ (c >>> 1); + } else { + c = c >>> 1; + } + } + crcTable[i] = c; +} + +},{"stream":139,"util":150}],89:[function(require,module,exports){ +(function (Buffer){ +// Copyright (c) 2012 Kuba Niegowski +// +// 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. + +'use strict'; + +var util = require('util'), + zlib = require('zlib'), + ChunkStream = require('./chunkstream'); + + +var Filter = module.exports = function(width, height, Bpp, data, options) { + ChunkStream.call(this); + + this._width = width; + this._height = height; + this._Bpp = Bpp; + this._data = data; + this._options = options; + + this._line = 0; + + if (!('filterType' in options) || options.filterType == -1) { + options.filterType = [0, 1, 2, 3, 4]; + } else if (typeof options.filterType == 'number') { + options.filterType = [options.filterType]; + } + + this._filters = { + 0: this._filterNone.bind(this), + 1: this._filterSub.bind(this), + 2: this._filterUp.bind(this), + 3: this._filterAvg.bind(this), + 4: this._filterPaeth.bind(this) + }; + + this.read(this._width * Bpp + 1, this._reverseFilterLine.bind(this)); +}; +util.inherits(Filter, ChunkStream); + + +var pixelBppMap = { + 1: { // L + 0: 0, + 1: 0, + 2: 0, + 3: 0xff + }, + 2: { // LA + 0: 0, + 1: 0, + 2: 0, + 3: 1 + }, + 3: { // RGB + 0: 0, + 1: 1, + 2: 2, + 3: 0xff + }, + 4: { // RGBA + 0: 0, + 1: 1, + 2: 2, + 3: 3 + } +}; + +Filter.prototype._reverseFilterLine = function(rawData) { + + var pxData = this._data, + pxLineLength = this._width << 2, + pxRowPos = this._line * pxLineLength, + filter = rawData[0]; + + if (filter == 0) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i]; + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] : 0xff; + } + } + + } else if (filter == 1) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + left = x > 0 ? pxData[pxPos + i - 4] : 0; + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + left : 0xff; + } + } + + } else if (filter == 2) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + up = this._line > 0 ? pxData[pxPos - pxLineLength + i] : 0; + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + up : 0xff; + } + + } + + } else if (filter == 3) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + left = x > 0 ? pxData[pxPos + i - 4] : 0, + up = this._line > 0 ? pxData[pxPos - pxLineLength + i] : 0, + add = Math.floor((left + up) / 2); + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + add : 0xff; + } + + } + + } else if (filter == 4) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + left = x > 0 ? pxData[pxPos + i - 4] : 0, + up = this._line > 0 ? pxData[pxPos - pxLineLength + i] : 0, + upLeft = x > 0 && this._line > 0 + ? pxData[pxPos - pxLineLength + i - 4] : 0, + add = PaethPredictor(left, up, upLeft); + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + add : 0xff; + } + } + } + + + this._line++; + + if (this._line < this._height) + this.read(this._width * this._Bpp + 1, this._reverseFilterLine.bind(this)); + else + this.emit('complete', this._data, this._width, this._height); +}; + + + + +Filter.prototype.filter = function() { + + var pxData = this._data, + rawData = new Buffer(((this._width << 2) + 1) * this._height); + + for (var y = 0; y < this._height; y++) { + + // find best filter for this line (with lowest sum of values) + var filterTypes = this._options.filterType, + min = Infinity, + sel = 0; + + for (var i = 0; i < filterTypes.length; i++) { + var sum = this._filters[filterTypes[i]](pxData, y, null); + if (sum < min) { + sel = filterTypes[i]; + min = sum; + } + } + + this._filters[sel](pxData, y, rawData); + } + return rawData; +}; + +Filter.prototype._filterNone = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (!rawData) { + for (var x = 0; x < pxRowLength; x++) + sum += Math.abs(pxData[y * pxRowLength + x]); + + } else { + rawData[y * rawRowLength] = 0; + pxData.copy(rawData, rawRowLength * y + 1, pxRowLength * y, pxRowLength * (y + 1)); + } + + return sum; +}; + +Filter.prototype._filterSub = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 1; + + for (var x = 0; x < pxRowLength; x++) { + + var left = x >= 4 ? pxData[y * pxRowLength + x - 4] : 0, + val = pxData[y * pxRowLength + x] - left; + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + +Filter.prototype._filterUp = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 2; + + for (var x = 0; x < pxRowLength; x++) { + + var up = y > 0 ? pxData[(y - 1) * pxRowLength + x] : 0, + val = pxData[y * pxRowLength + x] - up; + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + +Filter.prototype._filterAvg = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 3; + + for (var x = 0; x < pxRowLength; x++) { + + var left = x >= 4 ? pxData[y * pxRowLength + x - 4] : 0, + up = y > 0 ? pxData[(y - 1) * pxRowLength + x] : 0, + val = pxData[y * pxRowLength + x] - ((left + up) >> 1); + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + +Filter.prototype._filterPaeth = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 4; + + for (var x = 0; x < pxRowLength; x++) { + + var left = x >= 4 ? pxData[y * pxRowLength + x - 4] : 0, + up = y > 0 ? pxData[(y - 1) * pxRowLength + x] : 0, + upLeft = x >= 4 && y > 0 ? pxData[(y - 1) * pxRowLength + x - 4] : 0, + val = pxData[y * pxRowLength + x] - PaethPredictor(left, up, upLeft); + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + + + +var PaethPredictor = function(left, above, upLeft) { + + var p = left + above - upLeft, + pLeft = Math.abs(p - left), + pAbove = Math.abs(p - above), + pUpLeft = Math.abs(p - upLeft); + + if (pLeft <= pAbove && pLeft <= pUpLeft) return left; + else if (pAbove <= pUpLeft) return above; + else return upLeft; +}; + +}).call(this,require("buffer").Buffer) +},{"./chunkstream":86,"buffer":5,"util":150,"zlib":46}],90:[function(require,module,exports){ +(function (Buffer){ +// Copyright (c) 2012 Kuba Niegowski +// +// 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. + +'use strict'; + + +var util = require('util'), + Stream = require('stream'), + zlib = require('zlib'), + Filter = require('./filter'), + CrcStream = require('./crc'), + constants = require('./constants'); + + +var Packer = module.exports = function(options) { + Stream.call(this); + + this._options = options; + + options.deflateChunkSize = options.deflateChunkSize || 32 * 1024; + options.deflateLevel = options.deflateLevel || 9; + options.deflateStrategy = options.deflateStrategy || 3; + + this.readable = true; +}; +util.inherits(Packer, Stream); + + +Packer.prototype.pack = function(data, width, height) { + + // Signature + this.emit('data', new Buffer(constants.PNG_SIGNATURE)); + this.emit('data', this._packIHDR(width, height)); + + // filter pixel data + var filter = new Filter(width, height, 4, data, this._options); + var data = filter.filter(); + + // compress it + var deflate = zlib.createDeflate({ + chunkSize: this._options.deflateChunkSize, + level: this._options.deflateLevel, + strategy: this._options.deflateStrategy + }); + deflate.on('error', this.emit.bind(this, 'error')); + + deflate.on('data', function(data) { + this.emit('data', this._packIDAT(data)); + }.bind(this)); + + deflate.on('end', function() { + this.emit('data', this._packIEND()); + this.emit('end'); + }.bind(this)); + + deflate.end(data); +}; + +Packer.prototype._packChunk = function(type, data) { + + var len = (data ? data.length : 0), + buf = new Buffer(len + 12); + + buf.writeUInt32BE(len, 0); + buf.writeUInt32BE(type, 4); + + if (data) data.copy(buf, 8); + + buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4); + return buf; +}; + +Packer.prototype._packIHDR = function(width, height) { + + var buf = new Buffer(13); + buf.writeUInt32BE(width, 0); + buf.writeUInt32BE(height, 4); + buf[8] = 8; + buf[9] = 6; // colorType + buf[10] = 0; // compression + buf[11] = 0; // filter + buf[12] = 0; // interlace + + return this._packChunk(constants.TYPE_IHDR, buf); +}; + +Packer.prototype._packIDAT = function(data) { + return this._packChunk(constants.TYPE_IDAT, data); +}; + +Packer.prototype._packIEND = function() { + return this._packChunk(constants.TYPE_IEND, null); +}; + +}).call(this,require("buffer").Buffer) +},{"./constants":87,"./crc":88,"./filter":89,"buffer":5,"stream":139,"util":150,"zlib":46}],91:[function(require,module,exports){ +(function (Buffer){ +// Copyright (c) 2012 Kuba Niegowski +// +// 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. + +'use strict'; + + +var util = require('util'), + zlib = require('zlib'), + CrcStream = require('./crc'), + ChunkStream = require('./chunkstream'), + constants = require('./constants'), + Filter = require('./filter'); + + +var Parser = module.exports = function(options) { + ChunkStream.call(this); + + this._options = options; + options.checkCRC = options.checkCRC !== false; + + this._hasIHDR = false; + this._hasIEND = false; + + this._inflate = null; + this._filter = null; + this._crc = null; + + // input flags/metadata + this._palette = []; + this._colorType = 0; + + this._chunks = {}; + this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this); + this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this); + this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this); + this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this); + this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this); + this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this); + + this.writable = true; + + this.on('error', this._handleError.bind(this)); + this._handleSignature(); +}; +util.inherits(Parser, ChunkStream); + + +Parser.prototype._handleError = function() { + + this.writable = false; + + this.destroy(); + + if (this._inflate) + this._inflate.destroy(); +}; + +Parser.prototype._handleSignature = function() { + this.read(constants.PNG_SIGNATURE.length, + this._parseSignature.bind(this) + ); +}; + +Parser.prototype._parseSignature = function(data) { + + var signature = constants.PNG_SIGNATURE; + + for (var i = 0; i < signature.length; i++) { + if (data[i] != signature[i]) { + this.emit('error', new Error('Invalid file signature')); + return; + } + } + this.read(8, this._parseChunkBegin.bind(this)); +}; + +Parser.prototype._parseChunkBegin = function(data) { + + // chunk content length + var length = data.readUInt32BE(0); + + // chunk type + var type = data.readUInt32BE(4), + name = ''; + for (var i = 4; i < 8; i++) + name += String.fromCharCode(data[i]); + + // console.log('chunk ', name, length); + + // chunk flags + var ancillary = !!(data[4] & 0x20), // or critical + priv = !!(data[5] & 0x20), // or public + safeToCopy = !!(data[7] & 0x20); // or unsafe + + if (!this._hasIHDR && type != constants.TYPE_IHDR) { + this.emit('error', new Error('Expected IHDR on beggining')); + return; + } + + this._crc = new CrcStream(); + this._crc.write(new Buffer(name)); + + if (this._chunks[type]) { + return this._chunks[type](length); + + } else if (!ancillary) { + this.emit('error', new Error('Unsupported critical chunk type ' + name)); + return; + } else { + this.read(length + 4, this._skipChunk.bind(this)); + } +}; + +Parser.prototype._skipChunk = function(data) { + this.read(8, this._parseChunkBegin.bind(this)); +}; + +Parser.prototype._handleChunkEnd = function() { + this.read(4, this._parseChunkEnd.bind(this)); +}; + +Parser.prototype._parseChunkEnd = function(data) { + + var fileCrc = data.readInt32BE(0), + calcCrc = this._crc.crc32(); + + // check CRC + if (this._options.checkCRC && calcCrc != fileCrc) { + this.emit('error', new Error('Crc error')); + return; + } + + if (this._hasIEND) { + this.destroySoon(); + + } else { + this.read(8, this._parseChunkBegin.bind(this)); + } +}; + + +Parser.prototype._handleIHDR = function(length) { + this.read(length, this._parseIHDR.bind(this)); +}; +Parser.prototype._parseIHDR = function(data) { + + this._crc.write(data); + + var width = data.readUInt32BE(0), + height = data.readUInt32BE(4), + depth = data[8], + colorType = data[9], // bits: 1 palette, 2 color, 4 alpha + compr = data[10], + filter = data[11], + interlace = data[12]; + + // console.log(' width', width, 'height', height, + // 'depth', depth, 'colorType', colorType, + // 'compr', compr, 'filter', filter, 'interlace', interlace + // ); + + if (depth != 8) { + this.emit('error', new Error('Unsupported bit depth ' + depth)); + return; + } + if (!(colorType in colorTypeToBppMap)) { + this.emit('error', new Error('Unsupported color type')); + return; + } + if (compr != 0) { + this.emit('error', new Error('Unsupported compression method')); + return; + } + if (filter != 0) { + this.emit('error', new Error('Unsupported filter method')); + return; + } + if (interlace != 0) { + this.emit('error', new Error('Unsupported interlace method')); + return; + } + + this._colorType = colorType; + + this._data = new Buffer(width * height * 4); + this._filter = new Filter( + width, height, + colorTypeToBppMap[this._colorType], + this._data, + this._options + ); + + this._hasIHDR = true; + + this.emit('metadata', { + width: width, + height: height, + palette: !!(colorType & constants.COLOR_PALETTE), + color: !!(colorType & constants.COLOR_COLOR), + alpha: !!(colorType & constants.COLOR_ALPHA), + data: this._data + }); + + this._handleChunkEnd(); +}; + + +Parser.prototype._handlePLTE = function(length) { + this.read(length, this._parsePLTE.bind(this)); +}; +Parser.prototype._parsePLTE = function(data) { + + this._crc.write(data); + + var entries = Math.floor(data.length / 3); + // console.log('Palette:', entries); + + for (var i = 0; i < entries; i++) { + this._palette.push([ + data.readUInt8(i * 3), + data.readUInt8(i * 3 + 1), + data.readUInt8(i * 3 + 2 ), + 0xff + ]); + } + + this._handleChunkEnd(); +}; + +Parser.prototype._handleTRNS = function(length) { + this.read(length, this._parseTRNS.bind(this)); +}; +Parser.prototype._parseTRNS = function(data) { + + this._crc.write(data); + + // palette + if (this._colorType == 3) { + if (this._palette.length == 0) { + this.emit('error', new Error('Transparency chunk must be after palette')); + return; + } + if (data.length > this._palette.length) { + this.emit('error', new Error('More transparent colors than palette size')); + return; + } + for (var i = 0; i < this._palette.length; i++) { + this._palette[i][3] = i < data.length ? data.readUInt8(i) : 0xff; + } + } + + // for colorType 0 (grayscale) and 2 (rgb) + // there might be one gray/color defined as transparent + + this._handleChunkEnd(); +}; + +Parser.prototype._handleGAMA = function(length) { + this.read(length, this._parseGAMA.bind(this)); +}; +Parser.prototype._parseGAMA = function(data) { + + this._crc.write(data); + this.emit('gamma', data.readUInt32BE(0) / 100000); + + this._handleChunkEnd(); +}; + +Parser.prototype._handleIDAT = function(length) { + this.read(-length, this._parseIDAT.bind(this, length)); +}; +Parser.prototype._parseIDAT = function(length, data) { + + this._crc.write(data); + + if (this._colorType == 3 && this._palette.length == 0) + throw new Error('Expected palette not found'); + + if (!this._inflate) { + this._inflate = zlib.createInflate(); + + this._inflate.on('error', this.emit.bind(this, 'error')); + this._filter.on('complete', this._reverseFiltered.bind(this)); + + this._inflate.pipe(this._filter); + } + + this._inflate.write(data); + length -= data.length; + + if (length > 0) + this._handleIDAT(length); + else + this._handleChunkEnd(); +}; + + +Parser.prototype._handleIEND = function(length) { + this.read(length, this._parseIEND.bind(this)); +}; +Parser.prototype._parseIEND = function(data) { + + this._crc.write(data); + + // no more data to inflate + this._inflate.end(); + + this._hasIEND = true; + this._handleChunkEnd(); +}; + + +var colorTypeToBppMap = { + 0: 1, + 2: 3, + 3: 1, + 4: 2, + 6: 4 +}; + +Parser.prototype._reverseFiltered = function(data, width, height) { + + if (this._colorType == 3) { // paletted + + // use values from palette + var pxLineLength = width << 2; + + for (var y = 0; y < height; y++) { + var pxRowPos = y * pxLineLength; + + for (var x = 0; x < width; x++) { + var pxPos = pxRowPos + (x << 2), + color = this._palette[data[pxPos]]; + + for (var i = 0; i < 4; i++) + data[pxPos + i] = color[i]; + } + } + } + + this.emit('parsed', data); +}; + +}).call(this,require("buffer").Buffer) +},{"./chunkstream":86,"./constants":87,"./crc":88,"./filter":89,"buffer":5,"util":150,"zlib":46}],92:[function(require,module,exports){ +(function (process,Buffer){ +// Copyright (c) 2012 Kuba Niegowski +// +// 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. + +'use strict'; + + +var util = require('util'), + Stream = require('stream'), + Parser = require('./parser'), + Packer = require('./packer'); + + +var PNG = exports.PNG = function(options) { + Stream.call(this); + + options = options || {}; + + this.width = options.width || 0; + this.height = options.height || 0; + + this.data = this.width > 0 && this.height > 0 + ? new Buffer(4 * this.width * this.height) : null; + + if(options.fill && this.data){this.data.fill(0)}; + + this.gamma = 0; + this.readable = this.writable = true; + + this._parser = new Parser(options || {}); + + this._parser.on('error', this.emit.bind(this, 'error')); + this._parser.on('close', this._handleClose.bind(this)); + this._parser.on('metadata', this._metadata.bind(this)); + this._parser.on('gamma', this._gamma.bind(this)); + this._parser.on('parsed', function(data) { + this.data = data; + this.emit('parsed', data); + }.bind(this)); + + this._packer = new Packer(options); + this._packer.on('data', this.emit.bind(this, 'data')); + this._packer.on('end', this.emit.bind(this, 'end')); + this._parser.on('close', this._handleClose.bind(this)); + this._packer.on('error', this.emit.bind(this, 'error')); + +}; +util.inherits(PNG, Stream); + + +PNG.prototype.pack = function() { + + process.nextTick(function() { + this._packer.pack(this.data, this.width, this.height); + }.bind(this)); + + return this; +}; + + +PNG.prototype.parse = function(data, callback) { + + if (callback) { + var onParsed = null, onError = null; + + this.once('parsed', onParsed = function(data) { + this.removeListener('error', onError); + + this.data = data; + callback(null, this); + + }.bind(this)); + + this.once('error', onError = function(err) { + this.removeListener('parsed', onParsed); + + callback(err, null); + }.bind(this)); + } + + this.end(data); + return this; +}; + +PNG.prototype.write = function(data) { + this._parser.write(data); + return true; +}; + +PNG.prototype.end = function(data) { + this._parser.end(data); +}; + +PNG.prototype._metadata = function(metadata) { + this.width = metadata.width; + this.height = metadata.height; + this.data = metadata.data; + + delete metadata.data; + this.emit('metadata', metadata); +}; + +PNG.prototype._gamma = function(gamma) { + this.gamma = gamma; +}; + +PNG.prototype._handleClose = function() { + if (!this._parser.writable && !this._packer.readable) + this.emit('close'); +}; + + +PNG.prototype.bitblt = function(dst, sx, sy, w, h, dx, dy) { + + var src = this; + + if (sx > src.width || sy > src.height + || sx + w > src.width || sy + h > src.height) + throw new Error('bitblt reading outside image'); + if (dx > dst.width || dy > dst.height + || dx + w > dst.width || dy + h > dst.height) + throw new Error('bitblt writing outside image'); + + for (var y = 0; y < h; y++) { + src.data.copy(dst.data, + ((dy + y) * dst.width + dx) << 2, + ((sy + y) * src.width + sx) << 2, + ((sy + y) * src.width + sx + w) << 2 + ); + } + + return this; +}; + +}).call(this,require('_process'),require("buffer").Buffer) +},{"./packer":90,"./parser":91,"_process":117,"buffer":5,"stream":139,"util":150}],93:[function(require,module,exports){ // (c) Dean McNamee , 2013. // // https://github.com/deanm/omggif @@ -37607,7 +48672,7 @@ function GifReaderLZWOutputIndexStream(code_stream, p, output, output_length) { // CommonJS. try { exports.GifWriter = GifWriter; exports.GifReader = GifReader } catch(e) {} -},{}],74:[function(require,module,exports){ +},{}],94:[function(require,module,exports){ (function (process){ /** * Pace @@ -37881,7 +48946,7 @@ function formatNumber(number, decimals, dec_point, thousands_sep) { } }).call(this,require('_process')) -},{"_process":98,"charm":5}],75:[function(require,module,exports){ +},{"_process":117,"charm":6}],95:[function(require,module,exports){ (function (process){ // .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1, // backported and transplited with Babel, with backwards-compat fixes @@ -38187,7 +49252,7 @@ var substr = 'ab'.substr(-1) === 'b' ; }).call(this,require('_process')) -},{"_process":98}],76:[function(require,module,exports){ +},{"_process":117}],96:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -38383,7 +49448,7 @@ exports.dataToBitMap = function(data, bitmapInfo) { }; }).call(this,require("buffer").Buffer) -},{"./interlace":86,"buffer":4}],77:[function(require,module,exports){ +},{"./interlace":106,"buffer":5}],97:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -38451,7 +49516,7 @@ module.exports = function(data, width, height, options) { }; }).call(this,require("buffer").Buffer) -},{"./constants":79,"buffer":4}],78:[function(require,module,exports){ +},{"./constants":99,"buffer":5}],98:[function(require,module,exports){ (function (process,Buffer){ 'use strict'; @@ -38664,7 +49729,7 @@ ChunkStream.prototype._process = function() { }; }).call(this,require('_process'),require("buffer").Buffer) -},{"_process":98,"buffer":4,"stream":112,"util":135}],79:[function(require,module,exports){ +},{"_process":117,"buffer":5,"stream":139,"util":150}],99:[function(require,module,exports){ 'use strict'; @@ -38700,7 +49765,7 @@ module.exports = { GAMMA_DIVISION: 100000 }; -},{}],80:[function(require,module,exports){ +},{}],100:[function(require,module,exports){ 'use strict'; var crcTable = []; @@ -38746,7 +49811,7 @@ CrcCalculator.crc32 = function(buf) { return crc ^ -1; }; -},{}],81:[function(require,module,exports){ +},{}],101:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -38933,7 +49998,7 @@ module.exports = function(pxData, width, height, options, bpp) { }; }).call(this,require("buffer").Buffer) -},{"./paeth-predictor":90,"buffer":4}],82:[function(require,module,exports){ +},{"./paeth-predictor":110,"buffer":5}],102:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -38962,7 +50027,7 @@ var FilterAsync = module.exports = function(bitmapInfo) { util.inherits(FilterAsync, ChunkStream); }).call(this,require("buffer").Buffer) -},{"./chunkstream":78,"./filter-parse":84,"buffer":4,"util":135}],83:[function(require,module,exports){ +},{"./chunkstream":98,"./filter-parse":104,"buffer":5,"util":150}],103:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -38989,7 +50054,7 @@ exports.process = function(inBuffer, bitmapInfo) { return Buffer.concat(outBuffers); }; }).call(this,require("buffer").Buffer) -},{"./filter-parse":84,"./sync-reader":96,"buffer":4}],84:[function(require,module,exports){ +},{"./filter-parse":104,"./sync-reader":116,"buffer":5}],104:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -39164,7 +50229,7 @@ Filter.prototype._reverseFilterLine = function(rawData) { }; }).call(this,require("buffer").Buffer) -},{"./interlace":86,"./paeth-predictor":90,"buffer":4}],85:[function(require,module,exports){ +},{"./interlace":106,"./paeth-predictor":110,"buffer":5}],105:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -39257,7 +50322,7 @@ module.exports = function(indata, imageData) { }; }).call(this,require("buffer").Buffer) -},{"buffer":4}],86:[function(require,module,exports){ +},{"buffer":5}],106:[function(require,module,exports){ 'use strict'; // Adam 7 @@ -39345,7 +50410,7 @@ exports.getInterlaceIterator = function(width) { return (outerX * 4) + (outerY * width * 4); }; }; -},{}],87:[function(require,module,exports){ +},{}],107:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -39394,7 +50459,7 @@ PackerAsync.prototype.pack = function(data, width, height, gamma) { }; }).call(this,require("buffer").Buffer) -},{"./constants":79,"./packer":89,"buffer":4,"stream":112,"util":135}],88:[function(require,module,exports){ +},{"./constants":99,"./packer":109,"buffer":5,"stream":139,"util":150}],108:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -39446,7 +50511,7 @@ module.exports = function(metaData, opt) { }; }).call(this,require("buffer").Buffer) -},{"./constants":79,"./packer":89,"buffer":4,"zlib":41}],89:[function(require,module,exports){ +},{"./constants":99,"./packer":109,"buffer":5,"zlib":46}],109:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -39541,25 +50606,25 @@ Packer.prototype.packIEND = function() { return this._packChunk(constants.TYPE_IEND, null); }; }).call(this,require("buffer").Buffer) -},{"./bitpacker":77,"./constants":79,"./crc":80,"./filter-pack":81,"buffer":4,"zlib":41}],90:[function(require,module,exports){ -'use strict'; - -module.exports = function paethPredictor(left, above, upLeft) { - - var paeth = left + above - upLeft; - var pLeft = Math.abs(paeth - left); - var pAbove = Math.abs(paeth - above); - var pUpLeft = Math.abs(paeth - upLeft); - - if (pLeft <= pAbove && pLeft <= pUpLeft) { - return left; - } - if (pAbove <= pUpLeft) { - return above; - } - return upLeft; +},{"./bitpacker":97,"./constants":99,"./crc":100,"./filter-pack":101,"buffer":5,"zlib":46}],110:[function(require,module,exports){ +'use strict'; + +module.exports = function paethPredictor(left, above, upLeft) { + + var paeth = left + above - upLeft; + var pLeft = Math.abs(paeth - left); + var pAbove = Math.abs(paeth - above); + var pUpLeft = Math.abs(paeth - upLeft); + + if (pLeft <= pAbove && pLeft <= pUpLeft) { + return left; + } + if (pAbove <= pUpLeft) { + return above; + } + return upLeft; }; -},{}],91:[function(require,module,exports){ +},{}],111:[function(require,module,exports){ 'use strict'; var util = require('util'); @@ -39671,7 +50736,7 @@ ParserAsync.prototype._complete = function(filteredData) { this.emit('parsed', normalisedBitmapData); }; -},{"./bitmapper":76,"./chunkstream":78,"./filter-parse-async":82,"./format-normaliser":85,"./parser":93,"util":135,"zlib":41}],92:[function(require,module,exports){ +},{"./bitmapper":96,"./chunkstream":98,"./filter-parse-async":102,"./format-normaliser":105,"./parser":113,"util":150,"zlib":46}],112:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -39766,7 +50831,7 @@ module.exports = function(buffer, options) { }; }).call(this,require("buffer").Buffer) -},{"./bitmapper":76,"./filter-parse-sync":83,"./format-normaliser":85,"./parser":93,"./sync-reader":96,"buffer":4,"zlib":41}],93:[function(require,module,exports){ +},{"./bitmapper":96,"./filter-parse-sync":103,"./format-normaliser":105,"./parser":113,"./sync-reader":116,"buffer":5,"zlib":46}],113:[function(require,module,exports){ (function (Buffer){ 'use strict'; @@ -40060,7 +51125,7 @@ Parser.prototype._parseIEND = function(data) { }; }).call(this,require("buffer").Buffer) -},{"./constants":79,"./crc":80,"buffer":4}],94:[function(require,module,exports){ +},{"./constants":99,"./crc":100,"buffer":5}],114:[function(require,module,exports){ 'use strict'; @@ -40078,7 +51143,7 @@ exports.write = function(png) { return pack(png); }; -},{"./packer-sync":88,"./parser-sync":92}],95:[function(require,module,exports){ +},{"./packer-sync":108,"./parser-sync":112}],115:[function(require,module,exports){ (function (process,Buffer){ 'use strict'; @@ -40245,7 +51310,7 @@ PNG.prototype.adjustGamma = function() { }; }).call(this,require('_process'),require("buffer").Buffer) -},{"./packer-async":87,"./parser-async":91,"./png-sync":94,"_process":98,"buffer":4,"stream":112,"util":135}],96:[function(require,module,exports){ +},{"./packer-async":107,"./parser-async":111,"./png-sync":114,"_process":117,"buffer":5,"stream":139,"util":150}],116:[function(require,module,exports){ 'use strict'; var SyncReader = module.exports = function(buffer) { @@ -40298,55 +51363,7 @@ SyncReader.prototype.process = function() { }; -},{}],97:[function(require,module,exports){ -(function (process){ -'use strict'; - -if (!process.version || - process.version.indexOf('v0.') === 0 || - process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { - module.exports = { nextTick: nextTick }; -} else { - module.exports = process -} - -function nextTick(fn, arg1, arg2, arg3) { - if (typeof fn !== 'function') { - throw new TypeError('"callback" argument must be a function'); - } - var len = arguments.length; - var args, i; - switch (len) { - case 0: - case 1: - return process.nextTick(fn); - case 2: - return process.nextTick(function afterTickOne() { - fn.call(null, arg1); - }); - case 3: - return process.nextTick(function afterTickTwo() { - fn.call(null, arg1, arg2); - }); - case 4: - return process.nextTick(function afterTickThree() { - fn.call(null, arg1, arg2, arg3); - }); - default: - args = new Array(len - 1); - i = 0; - while (i < args.length) { - args[i++] = arguments[i]; - } - return process.nextTick(function afterTick() { - fn.apply(null, args); - }); - } -} - - -}).call(this,require('_process')) -},{"_process":98}],98:[function(require,module,exports){ +},{}],117:[function(require,module,exports){ // shim for using process in browser var process = module.exports = {}; @@ -40532,3721 +51549,10 @@ process.chdir = function (dir) { }; process.umask = function() { return 0; }; -},{}],99:[function(require,module,exports){ -arguments[4][29][0].apply(exports,arguments) -},{"./_stream_readable":101,"./_stream_writable":103,"_process":98,"core-util-is":8,"dup":29,"inherits":57}],100:[function(require,module,exports){ -arguments[4][30][0].apply(exports,arguments) -},{"./_stream_transform":102,"core-util-is":8,"dup":30,"inherits":57}],101:[function(require,module,exports){ -(function (process){ -// 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. - -module.exports = Readable; - -/**/ -var isArray = require('isarray'); -/**/ - - -/**/ -var Buffer = require('buffer').Buffer; -/**/ - -Readable.ReadableState = ReadableState; - -var EE = require('events').EventEmitter; - -/**/ -if (!EE.listenerCount) EE.listenerCount = function(emitter, type) { - return emitter.listeners(type).length; -}; -/**/ - -var Stream = require('stream'); - -/**/ -var util = require('core-util-is'); -util.inherits = require('inherits'); -/**/ - -var StringDecoder; - -util.inherits(Readable, Stream); - -function ReadableState(options, stream) { - options = options || {}; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024; - - // cast to ints. - this.highWaterMark = ~~this.highWaterMark; - - this.buffer = []; - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = false; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // In streams that never have any data, and do push(null) right away, - // the consumer can miss the 'end' event if they do some I/O before - // consuming the stream. So, we don't emit('end') until some reading - // happens. - this.calledRead = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, becuase any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - if (!StringDecoder) - StringDecoder = require('string_decoder/').StringDecoder; - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} - -function Readable(options) { - if (!(this instanceof Readable)) - return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - Stream.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function(chunk, encoding) { - var state = this._readableState; - - if (typeof chunk === 'string' && !state.objectMode) { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = new Buffer(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function(chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null || chunk === undefined) { - state.reading = false; - if (!state.ended) - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var e = new Error('stream.unshift() after end event'); - stream.emit('error', e); - } else { - if (state.decoder && !addToFront && !encoding) - chunk = state.decoder.write(chunk); - - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) { - state.buffer.unshift(chunk); - } else { - state.reading = false; - state.buffer.push(chunk); - } - - if (state.needReadable) - emitReadable(stream); - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - - - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && - (state.needReadable || - state.length < state.highWaterMark || - state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function(enc) { - if (!StringDecoder) - StringDecoder = require('string_decoder/').StringDecoder; - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; -}; - -// Don't raise the hwm > 128MB -var MAX_HWM = 0x800000; -function roundUpToNextPowerOf2(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 - n--; - for (var p = 1; p < 32; p <<= 1) n |= n >> p; - n++; - } - return n; -} - -function howMuchToRead(n, state) { - if (state.length === 0 && state.ended) - return 0; - - if (state.objectMode) - return n === 0 ? 0 : 1; - - if (n === null || isNaN(n)) { - // only flow one buffer at a time - if (state.flowing && state.buffer.length) - return state.buffer[0].length; - else - return state.length; - } - - if (n <= 0) - return 0; - - // If we're asking for more than the target buffer level, - // then raise the water mark. Bump up to the next highest - // power of 2, to prevent increasing it excessively in tiny - // amounts. - if (n > state.highWaterMark) - state.highWaterMark = roundUpToNextPowerOf2(n); - - // don't have that much. return null, unless we've ended. - if (n > state.length) { - if (!state.ended) { - state.needReadable = true; - return 0; - } else - return state.length; - } - - return n; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function(n) { - var state = this._readableState; - state.calledRead = true; - var nOrig = n; - var ret; - - if (typeof n !== 'number' || n > 0) - state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && - state.needReadable && - (state.length >= state.highWaterMark || state.ended)) { - emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - ret = null; - - // In cases where the decoder did not receive enough data - // to produce a full chunk, then immediately received an - // EOF, state.buffer will contain [, ]. - // howMuchToRead will see this and coerce the amount to - // read to zero (because it's looking at the length of the - // first in state.buffer), and we'll end up here. - // - // This can only happen via state.decoder -- no other venue - // exists for pushing a zero-length chunk into state.buffer - // and triggering this behavior. In this case, we return our - // remaining data and end the stream, if appropriate. - if (state.length > 0 && state.decoder) { - ret = fromList(n, state); - state.length -= ret.length; - } - - if (state.length === 0) - endReadable(this); - - return ret; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - - // if we currently have less than the highWaterMark, then also read some - if (state.length - n <= state.highWaterMark) - doRead = true; - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) - doRead = false; - - if (doRead) { - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) - state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - } - - // If _read called its callback synchronously, then `reading` - // will be false, and we need to re-evaluate how much data we - // can return to the user. - if (doRead && !state.reading) - n = howMuchToRead(nOrig, state); - - if (n > 0) - ret = fromList(n, state); - else - ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } - - state.length -= n; - - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (state.length === 0 && !state.ended) - state.needReadable = true; - - // If we happened to read() exactly the remaining amount in the - // buffer, and the EOF has been seen at this point, then make sure - // that we emit 'end' on the very next tick. - if (state.ended && !state.endEmitted && state.length === 0) - endReadable(this); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!Buffer.isBuffer(chunk) && - 'string' !== typeof chunk && - chunk !== null && - chunk !== undefined && - !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - - -function onEofChunk(stream, state) { - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // if we've ended and we have some data left, then emit - // 'readable' now to make sure it gets picked up. - if (state.length > 0) - emitReadable(stream); - else - endReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (state.emittedReadable) - return; - - state.emittedReadable = true; - if (state.sync) - process.nextTick(function() { - emitReadable_(stream); - }); - else - emitReadable_(stream); -} - -function emitReadable_(stream) { - stream.emit('readable'); -} - - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - process.nextTick(function() { - maybeReadMore_(stream, state); - }); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && - state.length < state.highWaterMark) { - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break; - else - len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function(n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function(dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - - var doEnd = (!pipeOpts || pipeOpts.end !== false) && - dest !== process.stdout && - dest !== process.stderr; - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) - process.nextTick(endFn); - else - src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - if (readable !== src) return; - cleanup(); - } - - function onend() { - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - function cleanup() { - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (!dest._writableState || dest._writableState.needDrain) - ondrain(); - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - unpipe(); - dest.removeListener('error', onerror); - if (EE.listenerCount(dest, 'error') === 0) - dest.emit('error', er); - } - // This is a brutally ugly hack to make sure that our error handler - // is attached before any userland ones. NEVER DO THIS. - if (!dest._events || !dest._events.error) - dest.on('error', onerror); - else if (isArray(dest._events.error)) - dest._events.error.unshift(onerror); - else - dest._events.error = [onerror, dest._events.error]; - - - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - // the handler that waits for readable events after all - // the data gets sucked out in flow. - // This would be easier to follow with a .once() handler - // in flow(), but that is too slow. - this.on('readable', pipeOnReadable); - - state.flowing = true; - process.nextTick(function() { - flow(src); - }); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function() { - var dest = this; - var state = src._readableState; - state.awaitDrain--; - if (state.awaitDrain === 0) - flow(src); - }; -} - -function flow(src) { - var state = src._readableState; - var chunk; - state.awaitDrain = 0; - - function write(dest, i, list) { - var written = dest.write(chunk); - if (false === written) { - state.awaitDrain++; - } - } - - while (state.pipesCount && null !== (chunk = src.read())) { - - if (state.pipesCount === 1) - write(state.pipes, 0, null); - else - forEach(state.pipes, write); - - src.emit('data', chunk); - - // if anyone needs a drain, then we have to wait for that. - if (state.awaitDrain > 0) - return; - } - - // if every destination was unpiped, either before entering this - // function, or in the while loop, then stop flowing. - // - // NB: This is a pretty rare edge case. - if (state.pipesCount === 0) { - state.flowing = false; - - // if there were data event listeners added, then switch to old mode. - if (EE.listenerCount(src, 'data') > 0) - emitDataEvents(src); - return; - } - - // at this point, no one needed a drain, so we just ran out of data - // on the next readable event, start it over again. - state.ranOut = true; -} - -function pipeOnReadable() { - if (this._readableState.ranOut) { - this._readableState.ranOut = false; - flow(this); - } -} - - -Readable.prototype.unpipe = function(dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) - return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) - return this; - - if (!dest) - dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - this.removeListener('readable', pipeOnReadable); - state.flowing = false; - if (dest) - dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - this.removeListener('readable', pipeOnReadable); - state.flowing = false; - - for (var i = 0; i < len; i++) - dests[i].emit('unpipe', this); - return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) - return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) - state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function(ev, fn) { - var res = Stream.prototype.on.call(this, ev, fn); - - if (ev === 'data' && !this._readableState.flowing) - emitDataEvents(this); - - if (ev === 'readable' && this.readable) { - var state = this._readableState; - if (!state.readableListening) { - state.readableListening = true; - state.emittedReadable = false; - state.needReadable = true; - if (!state.reading) { - this.read(0); - } else if (state.length) { - emitReadable(this, state); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function() { - emitDataEvents(this); - this.read(0); - this.emit('resume'); -}; - -Readable.prototype.pause = function() { - emitDataEvents(this, true); - this.emit('pause'); -}; - -function emitDataEvents(stream, startPaused) { - var state = stream._readableState; - - if (state.flowing) { - // https://github.com/isaacs/readable-stream/issues/16 - throw new Error('Cannot switch to old mode now.'); - } - - var paused = startPaused || false; - var readable = false; - - // convert to an old-style stream. - stream.readable = true; - stream.pipe = Stream.prototype.pipe; - stream.on = stream.addListener = Stream.prototype.on; - - stream.on('readable', function() { - readable = true; - - var c; - while (!paused && (null !== (c = stream.read()))) - stream.emit('data', c); - - if (c === null) { - readable = false; - stream._readableState.needReadable = true; - } - }); - - stream.pause = function() { - paused = true; - this.emit('pause'); - }; - - stream.resume = function() { - paused = false; - if (readable) - process.nextTick(function() { - stream.emit('readable'); - }); - else - this.read(0); - this.emit('resume'); - }; - - // now make it start, just in case it hadn't already. - stream.emit('readable'); -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function(stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function() { - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) - self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function(chunk) { - if (state.decoder) - chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - //if (state.objectMode && util.isNullOrUndefined(chunk)) - if (state.objectMode && (chunk === null || chunk === undefined)) - return; - else if (!state.objectMode && (!chunk || !chunk.length)) - return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (typeof stream[i] === 'function' && - typeof this[i] === 'undefined') { - this[i] = function(method) { return function() { - return stream[method].apply(stream, arguments); - }}(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function(ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function(n) { - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - - - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -function fromList(n, state) { - var list = state.buffer; - var length = state.length; - var stringMode = !!state.decoder; - var objectMode = !!state.objectMode; - var ret; - - // nothing in the list, definitely empty. - if (list.length === 0) - return null; - - if (length === 0) - ret = null; - else if (objectMode) - ret = list.shift(); - else if (!n || n >= length) { - // read it all, truncate the array. - if (stringMode) - ret = list.join(''); - else - ret = Buffer.concat(list, length); - list.length = 0; - } else { - // read just some of it. - if (n < list[0].length) { - // just take a part of the first list item. - // slice is the same for buffers and strings. - var buf = list[0]; - ret = buf.slice(0, n); - list[0] = buf.slice(n); - } else if (n === list[0].length) { - // first list is a perfect match - ret = list.shift(); - } else { - // complex case. - // we have enough to cover it, but it spans past the first buffer. - if (stringMode) - ret = ''; - else - ret = new Buffer(n); - - var c = 0; - for (var i = 0, l = list.length; i < l && c < n; i++) { - var buf = list[0]; - var cpy = Math.min(n - c, buf.length); - - if (stringMode) - ret += buf.slice(0, cpy); - else - buf.copy(ret, c, 0, cpy); - - if (cpy < buf.length) - list[0] = buf.slice(cpy); - else - list.shift(); - - c += cpy; - } - } - } - - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) - throw new Error('endReadable called on non-empty stream'); - - if (!state.endEmitted && state.calledRead) { - state.ended = true; - process.nextTick(function() { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } - }); - } -} - -function forEach (xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf (xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -}).call(this,require('_process')) -},{"_process":98,"buffer":4,"core-util-is":8,"events":43,"inherits":57,"isarray":104,"stream":112,"string_decoder/":105}],102:[function(require,module,exports){ -// 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. - - -// a transform stream is a readable/writable stream where you do -// something with the data. Sometimes it's called a "filter", -// but that's not a great name for it, since that implies a thing where -// some bits pass through, and others are simply ignored. (That would -// be a valid example of a transform, of course.) -// -// While the output is causally related to the input, it's not a -// necessarily symmetric or synchronous transformation. For example, -// a zlib stream might take multiple plain-text writes(), and then -// emit a single compressed chunk some time in the future. -// -// Here's how this works: -// -// The Transform stream has all the aspects of the readable and writable -// stream classes. When you write(chunk), that calls _write(chunk,cb) -// internally, and returns false if there's a lot of pending writes -// buffered up. When you call read(), that calls _read(n) until -// there's enough pending readable data buffered up. -// -// In a transform stream, the written data is placed in a buffer. When -// _read(n) is called, it transforms the queued up data, calling the -// buffered _write cb's as it consumes chunks. If consuming a single -// written chunk would result in multiple output chunks, then the first -// outputted bit calls the readcb, and subsequent chunks just go into -// the read buffer, and will cause it to emit 'readable' if necessary. -// -// This way, back-pressure is actually determined by the reading side, -// since _read has to be called to start processing a new chunk. However, -// a pathological inflate type of transform can cause excessive buffering -// here. For example, imagine a stream where every byte of input is -// interpreted as an integer from 0-255, and then results in that many -// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in -// 1kb of data being output. In this case, you could write a very small -// amount of input, and end up with a very large amount of output. In -// such a pathological inflating mechanism, there'd be no way to tell -// the system to stop doing the transform. A single 4MB write could -// cause the system to run out of memory. -// -// However, even in such a pathological case, only a single written chunk -// would be consumed, and then the rest would wait (un-transformed) until -// the results of the previous transformed chunk were consumed. - -module.exports = Transform; - -var Duplex = require('./_stream_duplex'); - -/**/ -var util = require('core-util-is'); -util.inherits = require('inherits'); -/**/ - -util.inherits(Transform, Duplex); - - -function TransformState(options, stream) { - this.afterTransform = function(er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) - return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) - stream.push(data); - - if (cb) - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} - - -function Transform(options) { - if (!(this instanceof Transform)) - return new Transform(options); - - Duplex.call(this, options); - - var ts = this._transformState = new TransformState(options, this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - this.once('finish', function() { - if ('function' === typeof this._flush) - this._flush(function(er) { - done(stream, er); - }); - else - done(stream); - }); -} - -Transform.prototype.push = function(chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function(chunk, encoding, cb) { - throw new Error('not implemented'); -}; - -Transform.prototype._write = function(chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || - rs.needReadable || - rs.length < rs.highWaterMark) - this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function(n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - - -function done(stream, er) { - if (er) - return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var rs = stream._readableState; - var ts = stream._transformState; - - if (ws.length) - throw new Error('calling transform done when ws.length != 0'); - - if (ts.transforming) - throw new Error('calling transform done when still transforming'); - - return stream.push(null); -} - -},{"./_stream_duplex":99,"core-util-is":8,"inherits":57}],103:[function(require,module,exports){ -(function (process){ -// 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. - -// A bit simpler than readable streams. -// Implement an async ._write(chunk, cb), and it'll handle all -// the drain event emission and buffering. - -module.exports = Writable; - -/**/ -var Buffer = require('buffer').Buffer; -/**/ - -Writable.WritableState = WritableState; - - -/**/ -var util = require('core-util-is'); -util.inherits = require('inherits'); -/**/ - -var Stream = require('stream'); - -util.inherits(Writable, Stream); - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; -} - -function WritableState(options, stream) { - options = options || {}; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - // cast to ints. - this.highWaterMark = ~~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, becuase any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function(er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.buffer = []; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; -} - -function Writable(options) { - var Duplex = require('./_stream_duplex'); - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) - return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - Stream.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function() { - this.emit('error', new Error('Cannot pipe. Not readable.')); -}; - - -function writeAfterEnd(stream, state, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - process.nextTick(function() { - cb(er); - }); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - if (!Buffer.isBuffer(chunk) && - 'string' !== typeof chunk && - chunk !== null && - chunk !== undefined && - !state.objectMode) { - var er = new TypeError('Invalid non-string/buffer chunk'); - stream.emit('error', er); - process.nextTick(function() { - cb(er); - }); - valid = false; - } - return valid; -} - -Writable.prototype.write = function(chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) - encoding = 'buffer'; - else if (!encoding) - encoding = state.defaultEncoding; - - if (typeof cb !== 'function') - cb = function() {}; - - if (state.ended) - writeAfterEnd(this, state, cb); - else if (validChunk(this, state, chunk, cb)) - ret = writeOrBuffer(this, state, chunk, encoding, cb); - - return ret; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && - state.decodeStrings !== false && - typeof chunk === 'string') { - chunk = new Buffer(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - if (Buffer.isBuffer(chunk)) - encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) - state.needDrain = true; - - if (state.writing) - state.buffer.push(new WriteReq(chunk, encoding, cb)); - else - doWrite(stream, state, len, chunk, encoding, cb); - - return ret; -} - -function doWrite(stream, state, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - if (sync) - process.nextTick(function() { - cb(er); - }); - else - cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) - onwriteError(stream, state, sync, er, cb); - else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(stream, state); - - if (!finished && !state.bufferProcessing && state.buffer.length) - clearBuffer(stream, state); - - if (sync) { - process.nextTick(function() { - afterWrite(stream, state, finished, cb); - }); - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) - onwriteDrain(stream, state); - cb(); - if (finished) - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - - for (var c = 0; c < state.buffer.length; c++) { - var entry = state.buffer[c]; - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, len, chunk, encoding, cb); - - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - c++; - break; - } - } - - state.bufferProcessing = false; - if (c < state.buffer.length) - state.buffer = state.buffer.slice(c); - else - state.buffer.length = 0; -} - -Writable.prototype._write = function(chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype.end = function(chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (typeof chunk !== 'undefined' && chunk !== null) - this.write(chunk, encoding); - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) - endWritable(this, state, cb); -}; - - -function needFinish(stream, state) { - return (state.ending && - state.length === 0 && - !state.finished && - !state.writing); -} - -function finishMaybe(stream, state) { - var need = needFinish(stream, state); - if (need) { - state.finished = true; - stream.emit('finish'); - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) - process.nextTick(cb); - else - stream.once('finish', cb); - } - state.ended = true; -} - -}).call(this,require('_process')) -},{"./_stream_duplex":99,"_process":98,"buffer":4,"core-util-is":8,"inherits":57,"stream":112}],104:[function(require,module,exports){ -arguments[4][28][0].apply(exports,arguments) -},{"dup":28}],105:[function(require,module,exports){ -arguments[4][35][0].apply(exports,arguments) -},{"buffer":4,"dup":35}],106:[function(require,module,exports){ -(function (process){ -var Stream = require('stream'); // hack to fix a circular dependency issue when used with browserify -exports = module.exports = require('./lib/_stream_readable.js'); -exports.Stream = Stream; -exports.Readable = exports; -exports.Writable = require('./lib/_stream_writable.js'); -exports.Duplex = require('./lib/_stream_duplex.js'); -exports.Transform = require('./lib/_stream_transform.js'); -exports.PassThrough = require('./lib/_stream_passthrough.js'); -if (!process.browser && process.env.READABLE_STREAM === 'disable') { - module.exports = require('stream'); -} - -}).call(this,require('_process')) -},{"./lib/_stream_duplex.js":99,"./lib/_stream_passthrough.js":100,"./lib/_stream_readable.js":101,"./lib/_stream_transform.js":102,"./lib/_stream_writable.js":103,"_process":98,"stream":112}],107:[function(require,module,exports){ -/* eslint-disable node/no-deprecated-api */ -var buffer = require('buffer') -var Buffer = buffer.Buffer - -// alternative to using Object.keys for old browsers -function copyProps (src, dst) { - for (var key in src) { - dst[key] = src[key] - } -} -if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { - module.exports = buffer -} else { - // Copy properties from require('buffer') - copyProps(buffer, exports) - exports.Buffer = SafeBuffer -} - -function SafeBuffer (arg, encodingOrOffset, length) { - return Buffer(arg, encodingOrOffset, length) -} - -// Copy static methods from Buffer -copyProps(Buffer, SafeBuffer) - -SafeBuffer.from = function (arg, encodingOrOffset, length) { - if (typeof arg === 'number') { - throw new TypeError('Argument must not be a number') - } - return Buffer(arg, encodingOrOffset, length) -} - -SafeBuffer.alloc = function (size, fill, encoding) { - if (typeof size !== 'number') { - throw new TypeError('Argument must be a number') - } - var buf = Buffer(size) - if (fill !== undefined) { - if (typeof encoding === 'string') { - buf.fill(fill, encoding) - } else { - buf.fill(fill) - } - } else { - buf.fill(0) - } - return buf -} - -SafeBuffer.allocUnsafe = function (size) { - if (typeof size !== 'number') { - throw new TypeError('Argument must be a number') - } - return Buffer(size) -} - -SafeBuffer.allocUnsafeSlow = function (size) { - if (typeof size !== 'number') { - throw new TypeError('Argument must be a number') - } - return buffer.SlowBuffer(size) -} - -},{"buffer":4}],108:[function(require,module,exports){ -var encode = require('./lib/encoder'), - decode = require('./lib/decoder'); - -module.exports = { - encode: encode, - decode: decode -}; - -},{"./lib/decoder":109,"./lib/encoder":110}],109:[function(require,module,exports){ -(function (Buffer){ -/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- / -/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ -/* - Copyright 2011 notmasteryet - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -*/ - -// - The JPEG specification can be found in the ITU CCITT Recommendation T.81 -// (www.w3.org/Graphics/JPEG/itu-t81.pdf) -// - The JFIF specification can be found in the JPEG File Interchange Format -// (www.w3.org/Graphics/JPEG/jfif3.pdf) -// - The Adobe Application-Specific JPEG markers in the Supporting the DCT Filters -// in PostScript Level 2, Technical Note #5116 -// (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf) - -var JpegImage = (function jpegImage() { - "use strict"; - var dctZigZag = new Int32Array([ - 0, - 1, 8, - 16, 9, 2, - 3, 10, 17, 24, - 32, 25, 18, 11, 4, - 5, 12, 19, 26, 33, 40, - 48, 41, 34, 27, 20, 13, 6, - 7, 14, 21, 28, 35, 42, 49, 56, - 57, 50, 43, 36, 29, 22, 15, - 23, 30, 37, 44, 51, 58, - 59, 52, 45, 38, 31, - 39, 46, 53, 60, - 61, 54, 47, - 55, 62, - 63 - ]); - - var dctCos1 = 4017 // cos(pi/16) - var dctSin1 = 799 // sin(pi/16) - var dctCos3 = 3406 // cos(3*pi/16) - var dctSin3 = 2276 // sin(3*pi/16) - var dctCos6 = 1567 // cos(6*pi/16) - var dctSin6 = 3784 // sin(6*pi/16) - var dctSqrt2 = 5793 // sqrt(2) - var dctSqrt1d2 = 2896 // sqrt(2) / 2 - - function constructor() { - } - - function buildHuffmanTable(codeLengths, values) { - var k = 0, code = [], i, j, length = 16; - while (length > 0 && !codeLengths[length - 1]) - length--; - code.push({children: [], index: 0}); - var p = code[0], q; - for (i = 0; i < length; i++) { - for (j = 0; j < codeLengths[i]; j++) { - p = code.pop(); - p.children[p.index] = values[k]; - while (p.index > 0) { - p = code.pop(); - } - p.index++; - code.push(p); - while (code.length <= i) { - code.push(q = {children: [], index: 0}); - p.children[p.index] = q.children; - p = q; - } - k++; - } - if (i + 1 < length) { - // p here points to last code - code.push(q = {children: [], index: 0}); - p.children[p.index] = q.children; - p = q; - } - } - return code[0].children; - } - - function decodeScan(data, offset, - frame, components, resetInterval, - spectralStart, spectralEnd, - successivePrev, successive) { - var precision = frame.precision; - var samplesPerLine = frame.samplesPerLine; - var scanLines = frame.scanLines; - var mcusPerLine = frame.mcusPerLine; - var progressive = frame.progressive; - var maxH = frame.maxH, maxV = frame.maxV; - - var startOffset = offset, bitsData = 0, bitsCount = 0; - function readBit() { - if (bitsCount > 0) { - bitsCount--; - return (bitsData >> bitsCount) & 1; - } - bitsData = data[offset++]; - if (bitsData == 0xFF) { - var nextByte = data[offset++]; - if (nextByte) { - throw "unexpected marker: " + ((bitsData << 8) | nextByte).toString(16); - } - // unstuff 0 - } - bitsCount = 7; - return bitsData >>> 7; - } - function decodeHuffman(tree) { - var node = tree, bit; - while ((bit = readBit()) !== null) { - node = node[bit]; - if (typeof node === 'number') - return node; - if (typeof node !== 'object') - throw "invalid huffman sequence"; - } - return null; - } - function receive(length) { - var n = 0; - while (length > 0) { - var bit = readBit(); - if (bit === null) return; - n = (n << 1) | bit; - length--; - } - return n; - } - function receiveAndExtend(length) { - var n = receive(length); - if (n >= 1 << (length - 1)) - return n; - return n + (-1 << length) + 1; - } - function decodeBaseline(component, zz) { - var t = decodeHuffman(component.huffmanTableDC); - var diff = t === 0 ? 0 : receiveAndExtend(t); - zz[0]= (component.pred += diff); - var k = 1; - while (k < 64) { - var rs = decodeHuffman(component.huffmanTableAC); - var s = rs & 15, r = rs >> 4; - if (s === 0) { - if (r < 15) - break; - k += 16; - continue; - } - k += r; - var z = dctZigZag[k]; - zz[z] = receiveAndExtend(s); - k++; - } - } - function decodeDCFirst(component, zz) { - var t = decodeHuffman(component.huffmanTableDC); - var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive); - zz[0] = (component.pred += diff); - } - function decodeDCSuccessive(component, zz) { - zz[0] |= readBit() << successive; - } - var eobrun = 0; - function decodeACFirst(component, zz) { - if (eobrun > 0) { - eobrun--; - return; - } - var k = spectralStart, e = spectralEnd; - while (k <= e) { - var rs = decodeHuffman(component.huffmanTableAC); - var s = rs & 15, r = rs >> 4; - if (s === 0) { - if (r < 15) { - eobrun = receive(r) + (1 << r) - 1; - break; - } - k += 16; - continue; - } - k += r; - var z = dctZigZag[k]; - zz[z] = receiveAndExtend(s) * (1 << successive); - k++; - } - } - var successiveACState = 0, successiveACNextValue; - function decodeACSuccessive(component, zz) { - var k = spectralStart, e = spectralEnd, r = 0; - while (k <= e) { - var z = dctZigZag[k]; - switch (successiveACState) { - case 0: // initial state - var rs = decodeHuffman(component.huffmanTableAC); - var s = rs & 15, r = rs >> 4; - if (s === 0) { - if (r < 15) { - eobrun = receive(r) + (1 << r); - successiveACState = 4; - } else { - r = 16; - successiveACState = 1; - } - } else { - if (s !== 1) - throw "invalid ACn encoding"; - successiveACNextValue = receiveAndExtend(s); - successiveACState = r ? 2 : 3; - } - continue; - case 1: // skipping r zero items - case 2: - if (zz[z]) - zz[z] += (readBit() << successive); - else { - r--; - if (r === 0) - successiveACState = successiveACState == 2 ? 3 : 0; - } - break; - case 3: // set value for a zero item - if (zz[z]) - zz[z] += (readBit() << successive); - else { - zz[z] = successiveACNextValue << successive; - successiveACState = 0; - } - break; - case 4: // eob - if (zz[z]) - zz[z] += (readBit() << successive); - break; - } - k++; - } - if (successiveACState === 4) { - eobrun--; - if (eobrun === 0) - successiveACState = 0; - } - } - function decodeMcu(component, decode, mcu, row, col) { - var mcuRow = (mcu / mcusPerLine) | 0; - var mcuCol = mcu % mcusPerLine; - var blockRow = mcuRow * component.v + row; - var blockCol = mcuCol * component.h + col; - decode(component, component.blocks[blockRow][blockCol]); - } - function decodeBlock(component, decode, mcu) { - var blockRow = (mcu / component.blocksPerLine) | 0; - var blockCol = mcu % component.blocksPerLine; - decode(component, component.blocks[blockRow][blockCol]); - } - - var componentsLength = components.length; - var component, i, j, k, n; - var decodeFn; - if (progressive) { - if (spectralStart === 0) - decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; - else - decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; - } else { - decodeFn = decodeBaseline; - } - - var mcu = 0, marker; - var mcuExpected; - if (componentsLength == 1) { - mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn; - } else { - mcuExpected = mcusPerLine * frame.mcusPerColumn; - } - if (!resetInterval) resetInterval = mcuExpected; - - var h, v; - while (mcu < mcuExpected) { - // reset interval stuff - for (i = 0; i < componentsLength; i++) - components[i].pred = 0; - eobrun = 0; - - if (componentsLength == 1) { - component = components[0]; - for (n = 0; n < resetInterval; n++) { - decodeBlock(component, decodeFn, mcu); - mcu++; - } - } else { - for (n = 0; n < resetInterval; n++) { - for (i = 0; i < componentsLength; i++) { - component = components[i]; - h = component.h; - v = component.v; - for (j = 0; j < v; j++) { - for (k = 0; k < h; k++) { - decodeMcu(component, decodeFn, mcu, j, k); - } - } - } - mcu++; - - // If we've reached our expected MCU's, stop decoding - if (mcu === mcuExpected) break; - } - } - - // find marker - bitsCount = 0; - marker = (data[offset] << 8) | data[offset + 1]; - if (marker < 0xFF00) { - throw "marker was not found"; - } - - if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx - offset += 2; - } - else - break; - } - - return offset - startOffset; - } - - function buildComponentData(frame, component) { - var lines = []; - var blocksPerLine = component.blocksPerLine; - var blocksPerColumn = component.blocksPerColumn; - var samplesPerLine = blocksPerLine << 3; - var R = new Int32Array(64), r = new Uint8Array(64); - - // A port of poppler's IDCT method which in turn is taken from: - // Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz, - // "Practical Fast 1-D DCT Algorithms with 11 Multiplications", - // IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989, - // 988-991. - function quantizeAndInverse(zz, dataOut, dataIn) { - var qt = component.quantizationTable; - var v0, v1, v2, v3, v4, v5, v6, v7, t; - var p = dataIn; - var i; - - // dequant - for (i = 0; i < 64; i++) - p[i] = zz[i] * qt[i]; - - // inverse DCT on rows - for (i = 0; i < 8; ++i) { - var row = 8 * i; - - // check for all-zero AC coefficients - if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && - p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && - p[7 + row] == 0) { - t = (dctSqrt2 * p[0 + row] + 512) >> 10; - p[0 + row] = t; - p[1 + row] = t; - p[2 + row] = t; - p[3 + row] = t; - p[4 + row] = t; - p[5 + row] = t; - p[6 + row] = t; - p[7 + row] = t; - continue; - } - - // stage 4 - v0 = (dctSqrt2 * p[0 + row] + 128) >> 8; - v1 = (dctSqrt2 * p[4 + row] + 128) >> 8; - v2 = p[2 + row]; - v3 = p[6 + row]; - v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8; - v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8; - v5 = p[3 + row] << 4; - v6 = p[5 + row] << 4; - - // stage 3 - t = (v0 - v1+ 1) >> 1; - v0 = (v0 + v1 + 1) >> 1; - v1 = t; - t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8; - v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8; - v3 = t; - t = (v4 - v6 + 1) >> 1; - v4 = (v4 + v6 + 1) >> 1; - v6 = t; - t = (v7 + v5 + 1) >> 1; - v5 = (v7 - v5 + 1) >> 1; - v7 = t; - - // stage 2 - t = (v0 - v3 + 1) >> 1; - v0 = (v0 + v3 + 1) >> 1; - v3 = t; - t = (v1 - v2 + 1) >> 1; - v1 = (v1 + v2 + 1) >> 1; - v2 = t; - t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; - v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; - v7 = t; - t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; - v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; - v6 = t; - - // stage 1 - p[0 + row] = v0 + v7; - p[7 + row] = v0 - v7; - p[1 + row] = v1 + v6; - p[6 + row] = v1 - v6; - p[2 + row] = v2 + v5; - p[5 + row] = v2 - v5; - p[3 + row] = v3 + v4; - p[4 + row] = v3 - v4; - } - - // inverse DCT on columns - for (i = 0; i < 8; ++i) { - var col = i; - - // check for all-zero AC coefficients - if (p[1*8 + col] == 0 && p[2*8 + col] == 0 && p[3*8 + col] == 0 && - p[4*8 + col] == 0 && p[5*8 + col] == 0 && p[6*8 + col] == 0 && - p[7*8 + col] == 0) { - t = (dctSqrt2 * dataIn[i+0] + 8192) >> 14; - p[0*8 + col] = t; - p[1*8 + col] = t; - p[2*8 + col] = t; - p[3*8 + col] = t; - p[4*8 + col] = t; - p[5*8 + col] = t; - p[6*8 + col] = t; - p[7*8 + col] = t; - continue; - } - - // stage 4 - v0 = (dctSqrt2 * p[0*8 + col] + 2048) >> 12; - v1 = (dctSqrt2 * p[4*8 + col] + 2048) >> 12; - v2 = p[2*8 + col]; - v3 = p[6*8 + col]; - v4 = (dctSqrt1d2 * (p[1*8 + col] - p[7*8 + col]) + 2048) >> 12; - v7 = (dctSqrt1d2 * (p[1*8 + col] + p[7*8 + col]) + 2048) >> 12; - v5 = p[3*8 + col]; - v6 = p[5*8 + col]; - - // stage 3 - t = (v0 - v1 + 1) >> 1; - v0 = (v0 + v1 + 1) >> 1; - v1 = t; - t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12; - v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12; - v3 = t; - t = (v4 - v6 + 1) >> 1; - v4 = (v4 + v6 + 1) >> 1; - v6 = t; - t = (v7 + v5 + 1) >> 1; - v5 = (v7 - v5 + 1) >> 1; - v7 = t; - - // stage 2 - t = (v0 - v3 + 1) >> 1; - v0 = (v0 + v3 + 1) >> 1; - v3 = t; - t = (v1 - v2 + 1) >> 1; - v1 = (v1 + v2 + 1) >> 1; - v2 = t; - t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; - v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; - v7 = t; - t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; - v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; - v6 = t; - - // stage 1 - p[0*8 + col] = v0 + v7; - p[7*8 + col] = v0 - v7; - p[1*8 + col] = v1 + v6; - p[6*8 + col] = v1 - v6; - p[2*8 + col] = v2 + v5; - p[5*8 + col] = v2 - v5; - p[3*8 + col] = v3 + v4; - p[4*8 + col] = v3 - v4; - } - - // convert to 8-bit integers - for (i = 0; i < 64; ++i) { - var sample = 128 + ((p[i] + 8) >> 4); - dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample; - } - } - - var i, j; - for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) { - var scanLine = blockRow << 3; - for (i = 0; i < 8; i++) - lines.push(new Uint8Array(samplesPerLine)); - for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) { - quantizeAndInverse(component.blocks[blockRow][blockCol], r, R); - - var offset = 0, sample = blockCol << 3; - for (j = 0; j < 8; j++) { - var line = lines[scanLine + j]; - for (i = 0; i < 8; i++) - line[sample + i] = r[offset++]; - } - } - } - return lines; - } - - function clampTo8bit(a) { - return a < 0 ? 0 : a > 255 ? 255 : a; - } - - constructor.prototype = { - load: function load(path) { - var xhr = new XMLHttpRequest(); - xhr.open("GET", path, true); - xhr.responseType = "arraybuffer"; - xhr.onload = (function() { - // TODO catch parse error - var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer); - this.parse(data); - if (this.onload) - this.onload(); - }).bind(this); - xhr.send(null); - }, - parse: function parse(data) { - var offset = 0, length = data.length; - function readUint16() { - var value = (data[offset] << 8) | data[offset + 1]; - offset += 2; - return value; - } - function readDataBlock() { - var length = readUint16(); - var array = data.subarray(offset, offset + length - 2); - offset += array.length; - return array; - } - function prepareComponents(frame) { - var maxH = 0, maxV = 0; - var component, componentId; - for (componentId in frame.components) { - if (frame.components.hasOwnProperty(componentId)) { - component = frame.components[componentId]; - if (maxH < component.h) maxH = component.h; - if (maxV < component.v) maxV = component.v; - } - } - var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH); - var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV); - for (componentId in frame.components) { - if (frame.components.hasOwnProperty(componentId)) { - component = frame.components[componentId]; - var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH); - var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV); - var blocksPerLineForMcu = mcusPerLine * component.h; - var blocksPerColumnForMcu = mcusPerColumn * component.v; - var blocks = []; - for (var i = 0; i < blocksPerColumnForMcu; i++) { - var row = []; - for (var j = 0; j < blocksPerLineForMcu; j++) - row.push(new Int32Array(64)); - blocks.push(row); - } - component.blocksPerLine = blocksPerLine; - component.blocksPerColumn = blocksPerColumn; - component.blocks = blocks; - } - } - frame.maxH = maxH; - frame.maxV = maxV; - frame.mcusPerLine = mcusPerLine; - frame.mcusPerColumn = mcusPerColumn; - } - var jfif = null; - var adobe = null; - var pixels = null; - var frame, resetInterval; - var quantizationTables = [], frames = []; - var huffmanTablesAC = [], huffmanTablesDC = []; - var fileMarker = readUint16(); - if (fileMarker != 0xFFD8) { // SOI (Start of Image) - throw "SOI not found"; - } - - fileMarker = readUint16(); - while (fileMarker != 0xFFD9) { // EOI (End of image) - var i, j, l; - switch(fileMarker) { - case 0xFF00: break; - case 0xFFE0: // APP0 (Application Specific) - case 0xFFE1: // APP1 - case 0xFFE2: // APP2 - case 0xFFE3: // APP3 - case 0xFFE4: // APP4 - case 0xFFE5: // APP5 - case 0xFFE6: // APP6 - case 0xFFE7: // APP7 - case 0xFFE8: // APP8 - case 0xFFE9: // APP9 - case 0xFFEA: // APP10 - case 0xFFEB: // APP11 - case 0xFFEC: // APP12 - case 0xFFED: // APP13 - case 0xFFEE: // APP14 - case 0xFFEF: // APP15 - case 0xFFFE: // COM (Comment) - var appData = readDataBlock(); - - if (fileMarker === 0xFFE0) { - if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 && - appData[3] === 0x46 && appData[4] === 0) { // 'JFIF\x00' - jfif = { - version: { major: appData[5], minor: appData[6] }, - densityUnits: appData[7], - xDensity: (appData[8] << 8) | appData[9], - yDensity: (appData[10] << 8) | appData[11], - thumbWidth: appData[12], - thumbHeight: appData[13], - thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13]) - }; - } - } - // TODO APP1 - Exif - if (fileMarker === 0xFFEE) { - if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F && - appData[3] === 0x62 && appData[4] === 0x65 && appData[5] === 0) { // 'Adobe\x00' - adobe = { - version: appData[6], - flags0: (appData[7] << 8) | appData[8], - flags1: (appData[9] << 8) | appData[10], - transformCode: appData[11] - }; - } - } - break; - - case 0xFFDB: // DQT (Define Quantization Tables) - var quantizationTablesLength = readUint16(); - var quantizationTablesEnd = quantizationTablesLength + offset - 2; - while (offset < quantizationTablesEnd) { - var quantizationTableSpec = data[offset++]; - var tableData = new Int32Array(64); - if ((quantizationTableSpec >> 4) === 0) { // 8 bit values - for (j = 0; j < 64; j++) { - var z = dctZigZag[j]; - tableData[z] = data[offset++]; - } - } else if ((quantizationTableSpec >> 4) === 1) { //16 bit - for (j = 0; j < 64; j++) { - var z = dctZigZag[j]; - tableData[z] = readUint16(); - } - } else - throw "DQT: invalid table spec"; - quantizationTables[quantizationTableSpec & 15] = tableData; - } - break; - - case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT) - case 0xFFC1: // SOF1 (Start of Frame, Extended DCT) - case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT) - readUint16(); // skip data length - frame = {}; - frame.extended = (fileMarker === 0xFFC1); - frame.progressive = (fileMarker === 0xFFC2); - frame.precision = data[offset++]; - frame.scanLines = readUint16(); - frame.samplesPerLine = readUint16(); - frame.components = {}; - frame.componentsOrder = []; - var componentsCount = data[offset++], componentId; - var maxH = 0, maxV = 0; - for (i = 0; i < componentsCount; i++) { - componentId = data[offset]; - var h = data[offset + 1] >> 4; - var v = data[offset + 1] & 15; - var qId = data[offset + 2]; - frame.componentsOrder.push(componentId); - frame.components[componentId] = { - h: h, - v: v, - quantizationTable: quantizationTables[qId] - }; - offset += 3; - } - prepareComponents(frame); - frames.push(frame); - break; - - case 0xFFC4: // DHT (Define Huffman Tables) - var huffmanLength = readUint16(); - for (i = 2; i < huffmanLength;) { - var huffmanTableSpec = data[offset++]; - var codeLengths = new Uint8Array(16); - var codeLengthSum = 0; - for (j = 0; j < 16; j++, offset++) - codeLengthSum += (codeLengths[j] = data[offset]); - var huffmanValues = new Uint8Array(codeLengthSum); - for (j = 0; j < codeLengthSum; j++, offset++) - huffmanValues[j] = data[offset]; - i += 17 + codeLengthSum; - - ((huffmanTableSpec >> 4) === 0 ? - huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = - buildHuffmanTable(codeLengths, huffmanValues); - } - break; - - case 0xFFDD: // DRI (Define Restart Interval) - readUint16(); // skip data length - resetInterval = readUint16(); - break; - - case 0xFFDA: // SOS (Start of Scan) - var scanLength = readUint16(); - var selectorsCount = data[offset++]; - var components = [], component; - for (i = 0; i < selectorsCount; i++) { - component = frame.components[data[offset++]]; - var tableSpec = data[offset++]; - component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; - component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; - components.push(component); - } - var spectralStart = data[offset++]; - var spectralEnd = data[offset++]; - var successiveApproximation = data[offset++]; - var processed = decodeScan(data, offset, - frame, components, resetInterval, - spectralStart, spectralEnd, - successiveApproximation >> 4, successiveApproximation & 15); - offset += processed; - break; - default: - if (data[offset - 3] == 0xFF && - data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) { - // could be incorrect encoding -- last 0xFF byte of the previous - // block was eaten by the encoder - offset -= 3; - break; - } - throw "unknown JPEG marker " + fileMarker.toString(16); - } - fileMarker = readUint16(); - } - if (frames.length != 1) - throw "only single frame JPEGs supported"; - - this.width = frame.samplesPerLine; - this.height = frame.scanLines; - this.jfif = jfif; - this.adobe = adobe; - this.components = []; - for (var i = 0; i < frame.componentsOrder.length; i++) { - var component = frame.components[frame.componentsOrder[i]]; - this.components.push({ - lines: buildComponentData(frame, component), - scaleX: component.h / frame.maxH, - scaleY: component.v / frame.maxV - }); - } - }, - getData: function getData(width, height) { - var scaleX = this.width / width, scaleY = this.height / height; - - var component1, component2, component3, component4; - var component1Line, component2Line, component3Line, component4Line; - var x, y; - var offset = 0; - var Y, Cb, Cr, K, C, M, Ye, R, G, B; - var colorTransform; - var dataLength = width * height * this.components.length; - var data = new Uint8Array(dataLength); - switch (this.components.length) { - case 1: - component1 = this.components[0]; - for (y = 0; y < height; y++) { - component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; - for (x = 0; x < width; x++) { - Y = component1Line[0 | (x * component1.scaleX * scaleX)]; - - data[offset++] = Y; - } - } - break; - case 2: - // PDF might compress two component data in custom colorspace - component1 = this.components[0]; - component2 = this.components[1]; - for (y = 0; y < height; y++) { - component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; - component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; - for (x = 0; x < width; x++) { - Y = component1Line[0 | (x * component1.scaleX * scaleX)]; - data[offset++] = Y; - Y = component2Line[0 | (x * component2.scaleX * scaleX)]; - data[offset++] = Y; - } - } - break; - case 3: - // The default transform for three components is true - colorTransform = true; - // The adobe transform marker overrides any previous setting - if (this.adobe && this.adobe.transformCode) - colorTransform = true; - else if (typeof this.colorTransform !== 'undefined') - colorTransform = !!this.colorTransform; - - component1 = this.components[0]; - component2 = this.components[1]; - component3 = this.components[2]; - for (y = 0; y < height; y++) { - component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; - component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; - component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]; - for (x = 0; x < width; x++) { - if (!colorTransform) { - R = component1Line[0 | (x * component1.scaleX * scaleX)]; - G = component2Line[0 | (x * component2.scaleX * scaleX)]; - B = component3Line[0 | (x * component3.scaleX * scaleX)]; - } else { - Y = component1Line[0 | (x * component1.scaleX * scaleX)]; - Cb = component2Line[0 | (x * component2.scaleX * scaleX)]; - Cr = component3Line[0 | (x * component3.scaleX * scaleX)]; - - R = clampTo8bit(Y + 1.402 * (Cr - 128)); - G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128)); - B = clampTo8bit(Y + 1.772 * (Cb - 128)); - } - - data[offset++] = R; - data[offset++] = G; - data[offset++] = B; - } - } - break; - case 4: - if (!this.adobe) - throw 'Unsupported color mode (4 components)'; - // The default transform for four components is false - colorTransform = false; - // The adobe transform marker overrides any previous setting - if (this.adobe && this.adobe.transformCode) - colorTransform = true; - else if (typeof this.colorTransform !== 'undefined') - colorTransform = !!this.colorTransform; - - component1 = this.components[0]; - component2 = this.components[1]; - component3 = this.components[2]; - component4 = this.components[3]; - for (y = 0; y < height; y++) { - component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; - component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; - component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]; - component4Line = component4.lines[0 | (y * component4.scaleY * scaleY)]; - for (x = 0; x < width; x++) { - if (!colorTransform) { - C = component1Line[0 | (x * component1.scaleX * scaleX)]; - M = component2Line[0 | (x * component2.scaleX * scaleX)]; - Ye = component3Line[0 | (x * component3.scaleX * scaleX)]; - K = component4Line[0 | (x * component4.scaleX * scaleX)]; - } else { - Y = component1Line[0 | (x * component1.scaleX * scaleX)]; - Cb = component2Line[0 | (x * component2.scaleX * scaleX)]; - Cr = component3Line[0 | (x * component3.scaleX * scaleX)]; - K = component4Line[0 | (x * component4.scaleX * scaleX)]; - - C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128)); - M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128)); - Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128)); - } - data[offset++] = C; - data[offset++] = M; - data[offset++] = Ye; - data[offset++] = K; - } - } - break; - default: - throw 'Unsupported color mode'; - } - return data; - }, - copyToImageData: function copyToImageData(imageData) { - var width = imageData.width, height = imageData.height; - var imageDataArray = imageData.data; - var data = this.getData(width, height); - var i = 0, j = 0, x, y; - var Y, K, C, M, R, G, B; - switch (this.components.length) { - case 1: - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - Y = data[i++]; - - imageDataArray[j++] = Y; - imageDataArray[j++] = Y; - imageDataArray[j++] = Y; - imageDataArray[j++] = 255; - } - } - break; - case 3: - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - R = data[i++]; - G = data[i++]; - B = data[i++]; - - imageDataArray[j++] = R; - imageDataArray[j++] = G; - imageDataArray[j++] = B; - imageDataArray[j++] = 255; - } - } - break; - case 4: - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - C = data[i++]; - M = data[i++]; - Y = data[i++]; - K = data[i++]; - - R = 255 - clampTo8bit(C * (1 - K / 255) + K); - G = 255 - clampTo8bit(M * (1 - K / 255) + K); - B = 255 - clampTo8bit(Y * (1 - K / 255) + K); - - imageDataArray[j++] = R; - imageDataArray[j++] = G; - imageDataArray[j++] = B; - imageDataArray[j++] = 255; - } - } - break; - default: - throw 'Unsupported color mode'; - } - } - }; - - return constructor; -})(); -module.exports = decode; - -function decode(jpegData) { - var arr = new Uint8Array(jpegData); - var decoder = new JpegImage(); - decoder.parse(arr); - var data = decoder.getData(decoder.width, decoder.height); - var buf = new Buffer(decoder.width * decoder.height * 4); - var n = 0; - for (var i = 0; i < buf.length; i++) { - buf[i + (i/3 | 0)] = data[n++]; - if (i % 4 == 3) buf[i] = 255; - } - return { - data: buf, - width: decoder.width, - height: decoder.height - }; -} - -}).call(this,require("buffer").Buffer) -},{"buffer":4}],110:[function(require,module,exports){ -(function (Buffer){ -/* - Copyright (c) 2008, Adobe Systems Incorporated - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - * Neither the name of Adobe Systems Incorporated nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS - IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, - THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -/* -JPEG encoder ported to JavaScript and optimized by Andreas Ritter, www.bytestrom.eu, 11/2009 - -Basic GUI blocking jpeg encoder -*/ - -var btoa = btoa || function(buf) { - return new Buffer(buf).toString('base64'); -}; - -function JPEGEncoder(quality) { - var self = this; - var fround = Math.round; - var ffloor = Math.floor; - var YTable = new Array(64); - var UVTable = new Array(64); - var fdtbl_Y = new Array(64); - var fdtbl_UV = new Array(64); - var YDC_HT; - var UVDC_HT; - var YAC_HT; - var UVAC_HT; - - var bitcode = new Array(65535); - var category = new Array(65535); - var outputfDCTQuant = new Array(64); - var DU = new Array(64); - var byteout = []; - var bytenew = 0; - var bytepos = 7; - - var YDU = new Array(64); - var UDU = new Array(64); - var VDU = new Array(64); - var clt = new Array(256); - var RGB_YUV_TABLE = new Array(2048); - var currentQuality; - - var ZigZag = [ - 0, 1, 5, 6,14,15,27,28, - 2, 4, 7,13,16,26,29,42, - 3, 8,12,17,25,30,41,43, - 9,11,18,24,31,40,44,53, - 10,19,23,32,39,45,52,54, - 20,22,33,38,46,51,55,60, - 21,34,37,47,50,56,59,61, - 35,36,48,49,57,58,62,63 - ]; - - var std_dc_luminance_nrcodes = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0]; - var std_dc_luminance_values = [0,1,2,3,4,5,6,7,8,9,10,11]; - var std_ac_luminance_nrcodes = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d]; - var std_ac_luminance_values = [ - 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12, - 0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07, - 0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, - 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0, - 0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16, - 0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, - 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39, - 0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49, - 0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, - 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69, - 0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79, - 0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, - 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98, - 0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7, - 0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, - 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5, - 0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4, - 0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, - 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea, - 0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8, - 0xf9,0xfa - ]; - - var std_dc_chrominance_nrcodes = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0]; - var std_dc_chrominance_values = [0,1,2,3,4,5,6,7,8,9,10,11]; - var std_ac_chrominance_nrcodes = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77]; - var std_ac_chrominance_values = [ - 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21, - 0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71, - 0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, - 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0, - 0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34, - 0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, - 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38, - 0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48, - 0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, - 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68, - 0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78, - 0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, - 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96, - 0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5, - 0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, - 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3, - 0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2, - 0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, - 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9, - 0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8, - 0xf9,0xfa - ]; - - function initQuantTables(sf){ - var YQT = [ - 16, 11, 10, 16, 24, 40, 51, 61, - 12, 12, 14, 19, 26, 58, 60, 55, - 14, 13, 16, 24, 40, 57, 69, 56, - 14, 17, 22, 29, 51, 87, 80, 62, - 18, 22, 37, 56, 68,109,103, 77, - 24, 35, 55, 64, 81,104,113, 92, - 49, 64, 78, 87,103,121,120,101, - 72, 92, 95, 98,112,100,103, 99 - ]; - - for (var i = 0; i < 64; i++) { - var t = ffloor((YQT[i]*sf+50)/100); - if (t < 1) { - t = 1; - } else if (t > 255) { - t = 255; - } - YTable[ZigZag[i]] = t; - } - var UVQT = [ - 17, 18, 24, 47, 99, 99, 99, 99, - 18, 21, 26, 66, 99, 99, 99, 99, - 24, 26, 56, 99, 99, 99, 99, 99, - 47, 66, 99, 99, 99, 99, 99, 99, - 99, 99, 99, 99, 99, 99, 99, 99, - 99, 99, 99, 99, 99, 99, 99, 99, - 99, 99, 99, 99, 99, 99, 99, 99, - 99, 99, 99, 99, 99, 99, 99, 99 - ]; - for (var j = 0; j < 64; j++) { - var u = ffloor((UVQT[j]*sf+50)/100); - if (u < 1) { - u = 1; - } else if (u > 255) { - u = 255; - } - UVTable[ZigZag[j]] = u; - } - var aasf = [ - 1.0, 1.387039845, 1.306562965, 1.175875602, - 1.0, 0.785694958, 0.541196100, 0.275899379 - ]; - var k = 0; - for (var row = 0; row < 8; row++) - { - for (var col = 0; col < 8; col++) - { - fdtbl_Y[k] = (1.0 / (YTable [ZigZag[k]] * aasf[row] * aasf[col] * 8.0)); - fdtbl_UV[k] = (1.0 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8.0)); - k++; - } - } - } - - function computeHuffmanTbl(nrcodes, std_table){ - var codevalue = 0; - var pos_in_table = 0; - var HT = new Array(); - for (var k = 1; k <= 16; k++) { - for (var j = 1; j <= nrcodes[k]; j++) { - HT[std_table[pos_in_table]] = []; - HT[std_table[pos_in_table]][0] = codevalue; - HT[std_table[pos_in_table]][1] = k; - pos_in_table++; - codevalue++; - } - codevalue*=2; - } - return HT; - } - - function initHuffmanTbl() - { - YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes,std_dc_luminance_values); - UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes,std_dc_chrominance_values); - YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes,std_ac_luminance_values); - UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes,std_ac_chrominance_values); - } - - function initCategoryNumber() - { - var nrlower = 1; - var nrupper = 2; - for (var cat = 1; cat <= 15; cat++) { - //Positive numbers - for (var nr = nrlower; nr>0] = 38470 * i; - RGB_YUV_TABLE[(i+ 512)>>0] = 7471 * i + 0x8000; - RGB_YUV_TABLE[(i+ 768)>>0] = -11059 * i; - RGB_YUV_TABLE[(i+1024)>>0] = -21709 * i; - RGB_YUV_TABLE[(i+1280)>>0] = 32768 * i + 0x807FFF; - RGB_YUV_TABLE[(i+1536)>>0] = -27439 * i; - RGB_YUV_TABLE[(i+1792)>>0] = - 5329 * i; - } - } - - // IO functions - function writeBits(bs) - { - var value = bs[0]; - var posval = bs[1]-1; - while ( posval >= 0 ) { - if (value & (1 << posval) ) { - bytenew |= (1 << bytepos); - } - posval--; - bytepos--; - if (bytepos < 0) { - if (bytenew == 0xFF) { - writeByte(0xFF); - writeByte(0); - } - else { - writeByte(bytenew); - } - bytepos=7; - bytenew=0; - } - } - } - - function writeByte(value) - { - //byteout.push(clt[value]); // write char directly instead of converting later - byteout.push(value); - } - - function writeWord(value) - { - writeByte((value>>8)&0xFF); - writeByte((value )&0xFF); - } - - // DCT & quantization core - function fDCTQuant(data, fdtbl) - { - var d0, d1, d2, d3, d4, d5, d6, d7; - /* Pass 1: process rows. */ - var dataOff=0; - var i; - const I8 = 8; - const I64 = 64; - for (i=0; i 0.0) ? ((fDCTQuant + 0.5)|0) : ((fDCTQuant - 0.5)|0); - //outputfDCTQuant[i] = fround(fDCTQuant); - - } - return outputfDCTQuant; - } - - function writeAPP0() - { - writeWord(0xFFE0); // marker - writeWord(16); // length - writeByte(0x4A); // J - writeByte(0x46); // F - writeByte(0x49); // I - writeByte(0x46); // F - writeByte(0); // = "JFIF",'\0' - writeByte(1); // versionhi - writeByte(1); // versionlo - writeByte(0); // xyunits - writeWord(1); // xdensity - writeWord(1); // ydensity - writeByte(0); // thumbnwidth - writeByte(0); // thumbnheight - } - - function writeSOF0(width, height) - { - writeWord(0xFFC0); // marker - writeWord(17); // length, truecolor YUV JPG - writeByte(8); // precision - writeWord(height); - writeWord(width); - writeByte(3); // nrofcomponents - writeByte(1); // IdY - writeByte(0x11); // HVY - writeByte(0); // QTY - writeByte(2); // IdU - writeByte(0x11); // HVU - writeByte(1); // QTU - writeByte(3); // IdV - writeByte(0x11); // HVV - writeByte(1); // QTV - } - - function writeDQT() - { - writeWord(0xFFDB); // marker - writeWord(132); // length - writeByte(0); - for (var i=0; i<64; i++) { - writeByte(YTable[i]); - } - writeByte(1); - for (var j=0; j<64; j++) { - writeByte(UVTable[j]); - } - } - - function writeDHT() - { - writeWord(0xFFC4); // marker - writeWord(0x01A2); // length - - writeByte(0); // HTYDCinfo - for (var i=0; i<16; i++) { - writeByte(std_dc_luminance_nrcodes[i+1]); - } - for (var j=0; j<=11; j++) { - writeByte(std_dc_luminance_values[j]); - } - - writeByte(0x10); // HTYACinfo - for (var k=0; k<16; k++) { - writeByte(std_ac_luminance_nrcodes[k+1]); - } - for (var l=0; l<=161; l++) { - writeByte(std_ac_luminance_values[l]); - } - - writeByte(1); // HTUDCinfo - for (var m=0; m<16; m++) { - writeByte(std_dc_chrominance_nrcodes[m+1]); - } - for (var n=0; n<=11; n++) { - writeByte(std_dc_chrominance_values[n]); - } - - writeByte(0x11); // HTUACinfo - for (var o=0; o<16; o++) { - writeByte(std_ac_chrominance_nrcodes[o+1]); - } - for (var p=0; p<=161; p++) { - writeByte(std_ac_chrominance_values[p]); - } - } - - function writeSOS() - { - writeWord(0xFFDA); // marker - writeWord(12); // length - writeByte(3); // nrofcomponents - writeByte(1); // IdY - writeByte(0); // HTY - writeByte(2); // IdU - writeByte(0x11); // HTU - writeByte(3); // IdV - writeByte(0x11); // HTV - writeByte(0); // Ss - writeByte(0x3f); // Se - writeByte(0); // Bf - } - - function processDU(CDU, fdtbl, DC, HTDC, HTAC){ - var EOB = HTAC[0x00]; - var M16zeroes = HTAC[0xF0]; - var pos; - const I16 = 16; - const I63 = 63; - const I64 = 64; - var DU_DCT = fDCTQuant(CDU, fdtbl); - //ZigZag reorder - for (var j=0;j0)&&(DU[end0pos]==0); end0pos--) {}; - //end0pos = first element in reverse order !=0 - if ( end0pos == 0) { - writeBits(EOB); - return DC; - } - var i = 1; - var lng; - while ( i <= end0pos ) { - var startpos = i; - for (; (DU[i]==0) && (i<=end0pos); ++i) {} - var nrzeroes = i-startpos; - if ( nrzeroes >= I16 ) { - lng = nrzeroes>>4; - for (var nrmarker=1; nrmarker <= lng; ++nrmarker) - writeBits(M16zeroes); - nrzeroes = nrzeroes&0xF; - } - pos = 32767+DU[i]; - writeBits(HTAC[(nrzeroes<<4)+category[pos]]); - writeBits(bitcode[pos]); - i++; - } - if ( end0pos != I63 ) { - writeBits(EOB); - } - return DC; - } - - function initCharLookupTable(){ - var sfcc = String.fromCharCode; - for(var i=0; i < 256; i++){ ///// ACHTUNG // 255 - clt[i] = sfcc(i); - } - } - - this.encode = function(image,quality) // image data object - { - var time_start = new Date().getTime(); - - if(quality) setQuality(quality); - - // Initialize bit writer - byteout = new Array(); - bytenew=0; - bytepos=7; - - // Add JPEG headers - writeWord(0xFFD8); // SOI - writeAPP0(); - writeDQT(); - writeSOF0(image.width,image.height); - writeDHT(); - writeSOS(); - - - // Encode 8x8 macroblocks - var DCY=0; - var DCU=0; - var DCV=0; - - bytenew=0; - bytepos=7; - - - this.encode.displayName = "_encode_"; - - var imageData = image.data; - var width = image.width; - var height = image.height; - - var quadWidth = width*4; - var tripleWidth = width*3; - - var x, y = 0; - var r, g, b; - var start,p, col,row,pos; - while(y < height){ - x = 0; - while(x < quadWidth){ - start = quadWidth * y + x; - p = start; - col = -1; - row = 0; - - for(pos=0; pos < 64; pos++){ - row = pos >> 3;// /8 - col = ( pos & 7 ) * 4; // %8 - p = start + ( row * quadWidth ) + col; - - if(y+row >= height){ // padding bottom - p-= (quadWidth*(y+1+row-height)); - } - - if(x+col >= quadWidth){ // padding right - p-= ((x+col) - quadWidth +4) - } - - r = imageData[ p++ ]; - g = imageData[ p++ ]; - b = imageData[ p++ ]; - - - /* // calculate YUV values dynamically - YDU[pos]=((( 0.29900)*r+( 0.58700)*g+( 0.11400)*b))-128; //-0x80 - UDU[pos]=(((-0.16874)*r+(-0.33126)*g+( 0.50000)*b)); - VDU[pos]=((( 0.50000)*r+(-0.41869)*g+(-0.08131)*b)); - */ - - // use lookup table (slightly faster) - YDU[pos] = ((RGB_YUV_TABLE[r] + RGB_YUV_TABLE[(g + 256)>>0] + RGB_YUV_TABLE[(b + 512)>>0]) >> 16)-128; - UDU[pos] = ((RGB_YUV_TABLE[(r + 768)>>0] + RGB_YUV_TABLE[(g + 1024)>>0] + RGB_YUV_TABLE[(b + 1280)>>0]) >> 16)-128; - VDU[pos] = ((RGB_YUV_TABLE[(r + 1280)>>0] + RGB_YUV_TABLE[(g + 1536)>>0] + RGB_YUV_TABLE[(b + 1792)>>0]) >> 16)-128; - - } - - DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT); - DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); - DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); - x+=32; - } - y+=8; - } - - - //////////////////////////////////////////////////////////////// - - // Do the bit alignment of the EOI marker - if ( bytepos >= 0 ) { - var fillbits = []; - fillbits[1] = bytepos+1; - fillbits[0] = (1<<(bytepos+1))-1; - writeBits(fillbits); - } - - writeWord(0xFFD9); //EOI - - //return new Uint8Array(byteout); - return new Buffer(byteout); - - var jpegDataUri = 'data:image/jpeg;base64,' + btoa(byteout.join('')); - - byteout = []; - - // benchmarking - var duration = new Date().getTime() - time_start; - //console.log('Encoding time: '+ duration + 'ms'); - // - - return jpegDataUri - } - - function setQuality(quality){ - if (quality <= 0) { - quality = 1; - } - if (quality > 100) { - quality = 100; - } - - if(currentQuality == quality) return // don't recalc if unchanged - - var sf = 0; - if (quality < 50) { - sf = Math.floor(5000 / quality); - } else { - sf = Math.floor(200 - quality*2); - } - - initQuantTables(sf); - currentQuality = quality; - //console.log('Quality set to: '+quality +'%'); - } - - function init(){ - var time_start = new Date().getTime(); - if(!quality) quality = 50; - // Create tables - initCharLookupTable() - initHuffmanTbl(); - initCategoryNumber(); - initRGBYUVTable(); - - setQuality(quality); - var duration = new Date().getTime() - time_start; - //console.log('Initialization '+ duration + 'ms'); - } - - init(); - -}; -module.exports = encode; - -function encode(imgData, qu) { - if (typeof qu === 'undefined') qu = 50; - var encoder = new JPEGEncoder(qu); - var data = encoder.encode(imgData, qu); - return { - data: data, - width: imgData.width, - height: imgData.height - }; -} - -// helper function to get the imageData of an existing image on the current page. -function getImageDataFromImage(idOrElement){ - var theImg = (typeof(idOrElement)=='string')? document.getElementById(idOrElement):idOrElement; - var cvs = document.createElement('canvas'); - cvs.width = theImg.width; - cvs.height = theImg.height; - var ctx = cvs.getContext("2d"); - ctx.drawImage(theImg,0,0); - - return (ctx.getImageData(0, 0, cvs.width, cvs.height)); -} - -}).call(this,require("buffer").Buffer) -},{"buffer":4}],111:[function(require,module,exports){ -(function (Buffer){ -'use strict' - -var ContentStream = require('contentstream') -var GifEncoder = require('gif-encoder') -var jpegJs = require('jpeg-js') -var PNG = require('pngjs-nozlib').PNG -var ndarray = require('ndarray') -var ops = require('ndarray-ops') -var through = require('through') - -function handleData (array, data, frame) { - var i, j, ptr = 0, c - if (array.shape.length === 4) { - return handleData(array.pick(frame), data, 0) - } else if (array.shape.length === 3) { - if (array.shape[2] === 3) { - ops.assign( - ndarray(data, - [array.shape[0], array.shape[1], 3], - [4, 4 * array.shape[0], 1]), - array) - ops.assigns( - ndarray(data, - [array.shape[0] * array.shape[1]], - [4], - 3), - 255) - } else if (array.shape[2] === 4) { - ops.assign( - ndarray(data, - [array.shape[0], array.shape[1], 4], - [4, array.shape[0] * 4, 1]), - array) - } else if (array.shape[2] === 1) { - ops.assign( - ndarray(data, - [array.shape[0], array.shape[1], 3], - [4, 4 * array.shape[0], 1]), - ndarray(array.data, - [array.shape[0], array.shape[1], 3], - [array.stride[0], array.stride[1], 0], - array.offset)) - ops.assigns( - ndarray(data, - [array.shape[0] * array.shape[1]], - [4], - 3), - 255) - } else { - return new Error('Incompatible array shape') - } - } else if (array.shape.length === 2) { - ops.assign( - ndarray(data, - [array.shape[0], array.shape[1], 3], - [4, 4 * array.shape[0], 1]), - ndarray(array.data, - [array.shape[0], array.shape[1], 3], - [array.stride[0], array.stride[1], 0], - array.offset)) - ops.assigns( - ndarray(data, - [array.shape[0] * array.shape[1]], - [4], - 3), - 255) - } else { - return new Error('Incompatible array shape') - } - return data -} - -function haderror (err) { - var result = through() - result.emit('error', err) - return result -} - -module.exports = function savePixels (array, type, options) { - options = options || {} - switch (type.toUpperCase()) { - case 'JPG': - case '.JPG': - case 'JPEG': - case '.JPEG': - case 'JPE': - case '.JPE': - var width = array.shape[0] - var height = array.shape[1] - var data = new Buffer(width * height * 4) - data = handleData(array, data) - var rawImageData = { - data: data, - width: width, - height: height - } - var jpegImageData = jpegJs.encode(rawImageData, options.quality) - return new ContentStream(jpegImageData.data) - - case 'GIF': - case '.GIF': - var frames = array.shape.length === 4 ? array.shape[0] : 1 - var width = array.shape.length === 4 ? array.shape[1] : array.shape[0] - var height = array.shape.length === 4 ? array.shape[2] : array.shape[1] - var data = new Buffer(width * height * 4) - var gif = new GifEncoder(width, height) - gif.writeHeader() - for (var i = 0; i < frames; i++) { - data = handleData(array, data, i) - gif.addFrame(data) - } - gif.finish() - return gif - - case 'PNG': - case '.PNG': - var png = new PNG({ - width: array.shape[0], - height: array.shape[1] - }) - var data = handleData(array, png.data) - if (typeof data === 'Error') return haderror(data) - png.data = data - return png.pack() - - case 'CANVAS': - var canvas = document.createElement('canvas') - var context = canvas.getContext('2d') - canvas.width = array.shape[0] - canvas.height = array.shape[1] - var imageData = context.getImageData(0, 0, canvas.width, canvas.height) - var data = imageData.data - data = handleData(array, data) - if (typeof data === 'Error') return haderror(data) - context.putImageData(imageData, 0, 0) - return canvas - - default: - return haderror(new Error('Unsupported file type: ' + type)) - } -} - -}).call(this,require("buffer").Buffer) -},{"buffer":4,"contentstream":7,"gif-encoder":25,"jpeg-js":108,"ndarray":71,"ndarray-ops":68,"pngjs-nozlib":95,"through":127}],112:[function(require,module,exports){ -// 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. - -module.exports = Stream; - -var EE = require('events').EventEmitter; -var inherits = require('inherits'); - -inherits(Stream, EE); -Stream.Readable = require('readable-stream/readable.js'); -Stream.Writable = require('readable-stream/writable.js'); -Stream.Duplex = require('readable-stream/duplex.js'); -Stream.Transform = require('readable-stream/transform.js'); -Stream.PassThrough = require('readable-stream/passthrough.js'); - -// Backwards-compat with node 0.4.x -Stream.Stream = 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; -}; - -},{"events":43,"inherits":57,"readable-stream/duplex.js":113,"readable-stream/passthrough.js":122,"readable-stream/readable.js":123,"readable-stream/transform.js":124,"readable-stream/writable.js":125}],113:[function(require,module,exports){ +},{}],118:[function(require,module,exports){ module.exports = require('./lib/_stream_duplex.js'); -},{"./lib/_stream_duplex.js":114}],114:[function(require,module,exports){ +},{"./lib/_stream_duplex.js":119}],119:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -44378,7 +51684,7 @@ Duplex.prototype._destroy = function (err, cb) { pna.nextTick(cb, err); }; -},{"./_stream_readable":116,"./_stream_writable":118,"core-util-is":8,"inherits":57,"process-nextick-args":97}],115:[function(require,module,exports){ +},{"./_stream_readable":121,"./_stream_writable":123,"core-util-is":15,"inherits":70,"process-nextick-args":128}],120:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -44426,7 +51732,7 @@ function PassThrough(options) { PassThrough.prototype._transform = function (chunk, encoding, cb) { cb(null, chunk); }; -},{"./_stream_transform":117,"core-util-is":8,"inherits":57}],116:[function(require,module,exports){ +},{"./_stream_transform":122,"core-util-is":15,"inherits":70}],121:[function(require,module,exports){ (function (process,global){ // Copyright Joyent, Inc. and other Node contributors. // @@ -45448,7 +52754,7 @@ function indexOf(xs, x) { return -1; } }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"./_stream_duplex":114,"./internal/streams/BufferList":119,"./internal/streams/destroy":120,"./internal/streams/stream":121,"_process":98,"core-util-is":8,"events":43,"inherits":57,"isarray":60,"process-nextick-args":97,"safe-buffer":107,"string_decoder/":126,"util":3}],117:[function(require,module,exports){ +},{"./_stream_duplex":119,"./internal/streams/BufferList":124,"./internal/streams/destroy":125,"./internal/streams/stream":126,"_process":117,"core-util-is":15,"events":48,"inherits":70,"isarray":127,"process-nextick-args":128,"safe-buffer":134,"string_decoder/":129,"util":4}],122:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -45663,7 +52969,7 @@ function done(stream, er, data) { return stream.push(null); } -},{"./_stream_duplex":114,"core-util-is":8,"inherits":57}],118:[function(require,module,exports){ +},{"./_stream_duplex":119,"core-util-is":15,"inherits":70}],123:[function(require,module,exports){ (function (process,global,setImmediate){ // Copyright Joyent, Inc. and other Node contributors. // @@ -46353,7 +53659,7 @@ Writable.prototype._destroy = function (err, cb) { cb(err); }; }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate) -},{"./_stream_duplex":114,"./internal/streams/destroy":120,"./internal/streams/stream":121,"_process":98,"core-util-is":8,"inherits":57,"process-nextick-args":97,"safe-buffer":107,"timers":128,"util-deprecate":133}],119:[function(require,module,exports){ +},{"./_stream_duplex":119,"./internal/streams/destroy":125,"./internal/streams/stream":126,"_process":117,"core-util-is":15,"inherits":70,"process-nextick-args":128,"safe-buffer":134,"timers":142,"util-deprecate":148}],124:[function(require,module,exports){ 'use strict'; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } @@ -46433,7 +53739,7 @@ if (util && util.inspect && util.inspect.custom) { return this.constructor.name + ' ' + obj; }; } -},{"safe-buffer":107,"util":3}],120:[function(require,module,exports){ +},{"safe-buffer":134,"util":4}],125:[function(require,module,exports){ 'use strict'; /**/ @@ -46508,28 +53814,65 @@ module.exports = { destroy: destroy, undestroy: undestroy }; -},{"process-nextick-args":97}],121:[function(require,module,exports){ +},{"process-nextick-args":128}],126:[function(require,module,exports){ module.exports = require('events').EventEmitter; -},{"events":43}],122:[function(require,module,exports){ -module.exports = require('./readable').PassThrough +},{"events":48}],127:[function(require,module,exports){ +var toString = {}.toString; -},{"./readable":123}],123:[function(require,module,exports){ -exports = module.exports = require('./lib/_stream_readable.js'); -exports.Stream = exports; -exports.Readable = exports; -exports.Writable = require('./lib/_stream_writable.js'); -exports.Duplex = require('./lib/_stream_duplex.js'); -exports.Transform = require('./lib/_stream_transform.js'); -exports.PassThrough = require('./lib/_stream_passthrough.js'); +module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; +}; -},{"./lib/_stream_duplex.js":114,"./lib/_stream_passthrough.js":115,"./lib/_stream_readable.js":116,"./lib/_stream_transform.js":117,"./lib/_stream_writable.js":118}],124:[function(require,module,exports){ -module.exports = require('./readable').Transform +},{}],128:[function(require,module,exports){ +(function (process){ +'use strict'; -},{"./readable":123}],125:[function(require,module,exports){ -module.exports = require('./lib/_stream_writable.js'); +if (!process.version || + process.version.indexOf('v0.') === 0 || + process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { + module.exports = { nextTick: nextTick }; +} else { + module.exports = process +} -},{"./lib/_stream_writable.js":118}],126:[function(require,module,exports){ +function nextTick(fn, arg1, arg2, arg3) { + if (typeof fn !== 'function') { + throw new TypeError('"callback" argument must be a function'); + } + var len = arguments.length; + var args, i; + switch (len) { + case 0: + case 1: + return process.nextTick(fn); + case 2: + return process.nextTick(function afterTickOne() { + fn.call(null, arg1); + }); + case 3: + return process.nextTick(function afterTickTwo() { + fn.call(null, arg1, arg2); + }); + case 4: + return process.nextTick(function afterTickThree() { + fn.call(null, arg1, arg2, arg3); + }); + default: + args = new Array(len - 1); + i = 0; + while (i < args.length) { + args[i++] = arguments[i]; + } + return process.nextTick(function afterTick() { + fn.apply(null, args); + }); + } +} + + +}).call(this,require('_process')) +},{"_process":117}],129:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -46826,7 +54169,1573 @@ function simpleWrite(buf) { function simpleEnd(buf) { return buf && buf.length ? this.write(buf) : ''; } -},{"safe-buffer":107}],127:[function(require,module,exports){ +},{"safe-buffer":134}],130:[function(require,module,exports){ +module.exports = require('./readable').PassThrough + +},{"./readable":131}],131:[function(require,module,exports){ +exports = module.exports = require('./lib/_stream_readable.js'); +exports.Stream = exports; +exports.Readable = exports; +exports.Writable = require('./lib/_stream_writable.js'); +exports.Duplex = require('./lib/_stream_duplex.js'); +exports.Transform = require('./lib/_stream_transform.js'); +exports.PassThrough = require('./lib/_stream_passthrough.js'); + +},{"./lib/_stream_duplex.js":119,"./lib/_stream_passthrough.js":120,"./lib/_stream_readable.js":121,"./lib/_stream_transform.js":122,"./lib/_stream_writable.js":123}],132:[function(require,module,exports){ +module.exports = require('./readable').Transform + +},{"./readable":131}],133:[function(require,module,exports){ +module.exports = require('./lib/_stream_writable.js'); + +},{"./lib/_stream_writable.js":123}],134:[function(require,module,exports){ +/* eslint-disable node/no-deprecated-api */ +var buffer = require('buffer') +var Buffer = buffer.Buffer + +// alternative to using Object.keys for old browsers +function copyProps (src, dst) { + for (var key in src) { + dst[key] = src[key] + } +} +if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer +} else { + // Copy properties from require('buffer') + copyProps(buffer, exports) + exports.Buffer = SafeBuffer +} + +function SafeBuffer (arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length) +} + +// Copy static methods from Buffer +copyProps(Buffer, SafeBuffer) + +SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number') + } + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + var buf = Buffer(size) + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + } else { + buf.fill(0) + } + return buf +} + +SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return Buffer(size) +} + +SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return buffer.SlowBuffer(size) +} + +},{"buffer":5}],135:[function(require,module,exports){ +arguments[4][67][0].apply(exports,arguments) +},{"./lib/decoder":136,"./lib/encoder":137,"dup":67}],136:[function(require,module,exports){ +(function (Buffer){ +/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- / +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* + Copyright 2011 notmasteryet + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +// - The JPEG specification can be found in the ITU CCITT Recommendation T.81 +// (www.w3.org/Graphics/JPEG/itu-t81.pdf) +// - The JFIF specification can be found in the JPEG File Interchange Format +// (www.w3.org/Graphics/JPEG/jfif3.pdf) +// - The Adobe Application-Specific JPEG markers in the Supporting the DCT Filters +// in PostScript Level 2, Technical Note #5116 +// (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf) + +var JpegImage = (function jpegImage() { + "use strict"; + var dctZigZag = new Int32Array([ + 0, + 1, 8, + 16, 9, 2, + 3, 10, 17, 24, + 32, 25, 18, 11, 4, + 5, 12, 19, 26, 33, 40, + 48, 41, 34, 27, 20, 13, 6, + 7, 14, 21, 28, 35, 42, 49, 56, + 57, 50, 43, 36, 29, 22, 15, + 23, 30, 37, 44, 51, 58, + 59, 52, 45, 38, 31, + 39, 46, 53, 60, + 61, 54, 47, + 55, 62, + 63 + ]); + + var dctCos1 = 4017 // cos(pi/16) + var dctSin1 = 799 // sin(pi/16) + var dctCos3 = 3406 // cos(3*pi/16) + var dctSin3 = 2276 // sin(3*pi/16) + var dctCos6 = 1567 // cos(6*pi/16) + var dctSin6 = 3784 // sin(6*pi/16) + var dctSqrt2 = 5793 // sqrt(2) + var dctSqrt1d2 = 2896 // sqrt(2) / 2 + + function constructor() { + } + + function buildHuffmanTable(codeLengths, values) { + var k = 0, code = [], i, j, length = 16; + while (length > 0 && !codeLengths[length - 1]) + length--; + code.push({children: [], index: 0}); + var p = code[0], q; + for (i = 0; i < length; i++) { + for (j = 0; j < codeLengths[i]; j++) { + p = code.pop(); + p.children[p.index] = values[k]; + while (p.index > 0) { + p = code.pop(); + } + p.index++; + code.push(p); + while (code.length <= i) { + code.push(q = {children: [], index: 0}); + p.children[p.index] = q.children; + p = q; + } + k++; + } + if (i + 1 < length) { + // p here points to last code + code.push(q = {children: [], index: 0}); + p.children[p.index] = q.children; + p = q; + } + } + return code[0].children; + } + + function decodeScan(data, offset, + frame, components, resetInterval, + spectralStart, spectralEnd, + successivePrev, successive) { + var precision = frame.precision; + var samplesPerLine = frame.samplesPerLine; + var scanLines = frame.scanLines; + var mcusPerLine = frame.mcusPerLine; + var progressive = frame.progressive; + var maxH = frame.maxH, maxV = frame.maxV; + + var startOffset = offset, bitsData = 0, bitsCount = 0; + function readBit() { + if (bitsCount > 0) { + bitsCount--; + return (bitsData >> bitsCount) & 1; + } + bitsData = data[offset++]; + if (bitsData == 0xFF) { + var nextByte = data[offset++]; + if (nextByte) { + throw "unexpected marker: " + ((bitsData << 8) | nextByte).toString(16); + } + // unstuff 0 + } + bitsCount = 7; + return bitsData >>> 7; + } + function decodeHuffman(tree) { + var node = tree, bit; + while ((bit = readBit()) !== null) { + node = node[bit]; + if (typeof node === 'number') + return node; + if (typeof node !== 'object') + throw "invalid huffman sequence"; + } + return null; + } + function receive(length) { + var n = 0; + while (length > 0) { + var bit = readBit(); + if (bit === null) return; + n = (n << 1) | bit; + length--; + } + return n; + } + function receiveAndExtend(length) { + var n = receive(length); + if (n >= 1 << (length - 1)) + return n; + return n + (-1 << length) + 1; + } + function decodeBaseline(component, zz) { + var t = decodeHuffman(component.huffmanTableDC); + var diff = t === 0 ? 0 : receiveAndExtend(t); + zz[0]= (component.pred += diff); + var k = 1; + while (k < 64) { + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) + break; + k += 16; + continue; + } + k += r; + var z = dctZigZag[k]; + zz[z] = receiveAndExtend(s); + k++; + } + } + function decodeDCFirst(component, zz) { + var t = decodeHuffman(component.huffmanTableDC); + var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive); + zz[0] = (component.pred += diff); + } + function decodeDCSuccessive(component, zz) { + zz[0] |= readBit() << successive; + } + var eobrun = 0; + function decodeACFirst(component, zz) { + if (eobrun > 0) { + eobrun--; + return; + } + var k = spectralStart, e = spectralEnd; + while (k <= e) { + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) { + eobrun = receive(r) + (1 << r) - 1; + break; + } + k += 16; + continue; + } + k += r; + var z = dctZigZag[k]; + zz[z] = receiveAndExtend(s) * (1 << successive); + k++; + } + } + var successiveACState = 0, successiveACNextValue; + function decodeACSuccessive(component, zz) { + var k = spectralStart, e = spectralEnd, r = 0; + while (k <= e) { + var z = dctZigZag[k]; + switch (successiveACState) { + case 0: // initial state + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) { + eobrun = receive(r) + (1 << r); + successiveACState = 4; + } else { + r = 16; + successiveACState = 1; + } + } else { + if (s !== 1) + throw "invalid ACn encoding"; + successiveACNextValue = receiveAndExtend(s); + successiveACState = r ? 2 : 3; + } + continue; + case 1: // skipping r zero items + case 2: + if (zz[z]) + zz[z] += (readBit() << successive); + else { + r--; + if (r === 0) + successiveACState = successiveACState == 2 ? 3 : 0; + } + break; + case 3: // set value for a zero item + if (zz[z]) + zz[z] += (readBit() << successive); + else { + zz[z] = successiveACNextValue << successive; + successiveACState = 0; + } + break; + case 4: // eob + if (zz[z]) + zz[z] += (readBit() << successive); + break; + } + k++; + } + if (successiveACState === 4) { + eobrun--; + if (eobrun === 0) + successiveACState = 0; + } + } + function decodeMcu(component, decode, mcu, row, col) { + var mcuRow = (mcu / mcusPerLine) | 0; + var mcuCol = mcu % mcusPerLine; + var blockRow = mcuRow * component.v + row; + var blockCol = mcuCol * component.h + col; + decode(component, component.blocks[blockRow][blockCol]); + } + function decodeBlock(component, decode, mcu) { + var blockRow = (mcu / component.blocksPerLine) | 0; + var blockCol = mcu % component.blocksPerLine; + decode(component, component.blocks[blockRow][blockCol]); + } + + var componentsLength = components.length; + var component, i, j, k, n; + var decodeFn; + if (progressive) { + if (spectralStart === 0) + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + else + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } else { + decodeFn = decodeBaseline; + } + + var mcu = 0, marker; + var mcuExpected; + if (componentsLength == 1) { + mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn; + } else { + mcuExpected = mcusPerLine * frame.mcusPerColumn; + } + if (!resetInterval) resetInterval = mcuExpected; + + var h, v; + while (mcu < mcuExpected) { + // reset interval stuff + for (i = 0; i < componentsLength; i++) + components[i].pred = 0; + eobrun = 0; + + if (componentsLength == 1) { + component = components[0]; + for (n = 0; n < resetInterval; n++) { + decodeBlock(component, decodeFn, mcu); + mcu++; + } + } else { + for (n = 0; n < resetInterval; n++) { + for (i = 0; i < componentsLength; i++) { + component = components[i]; + h = component.h; + v = component.v; + for (j = 0; j < v; j++) { + for (k = 0; k < h; k++) { + decodeMcu(component, decodeFn, mcu, j, k); + } + } + } + mcu++; + + // If we've reached our expected MCU's, stop decoding + if (mcu === mcuExpected) break; + } + } + + // find marker + bitsCount = 0; + marker = (data[offset] << 8) | data[offset + 1]; + if (marker < 0xFF00) { + throw "marker was not found"; + } + + if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx + offset += 2; + } + else + break; + } + + return offset - startOffset; + } + + function buildComponentData(frame, component) { + var lines = []; + var blocksPerLine = component.blocksPerLine; + var blocksPerColumn = component.blocksPerColumn; + var samplesPerLine = blocksPerLine << 3; + var R = new Int32Array(64), r = new Uint8Array(64); + + // A port of poppler's IDCT method which in turn is taken from: + // Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz, + // "Practical Fast 1-D DCT Algorithms with 11 Multiplications", + // IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989, + // 988-991. + function quantizeAndInverse(zz, dataOut, dataIn) { + var qt = component.quantizationTable; + var v0, v1, v2, v3, v4, v5, v6, v7, t; + var p = dataIn; + var i; + + // dequant + for (i = 0; i < 64; i++) + p[i] = zz[i] * qt[i]; + + // inverse DCT on rows + for (i = 0; i < 8; ++i) { + var row = 8 * i; + + // check for all-zero AC coefficients + if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && + p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && + p[7 + row] == 0) { + t = (dctSqrt2 * p[0 + row] + 512) >> 10; + p[0 + row] = t; + p[1 + row] = t; + p[2 + row] = t; + p[3 + row] = t; + p[4 + row] = t; + p[5 + row] = t; + p[6 + row] = t; + p[7 + row] = t; + continue; + } + + // stage 4 + v0 = (dctSqrt2 * p[0 + row] + 128) >> 8; + v1 = (dctSqrt2 * p[4 + row] + 128) >> 8; + v2 = p[2 + row]; + v3 = p[6 + row]; + v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8; + v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8; + v5 = p[3 + row] << 4; + v6 = p[5 + row] << 4; + + // stage 3 + t = (v0 - v1+ 1) >> 1; + v0 = (v0 + v1 + 1) >> 1; + v1 = t; + t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8; + v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8; + v3 = t; + t = (v4 - v6 + 1) >> 1; + v4 = (v4 + v6 + 1) >> 1; + v6 = t; + t = (v7 + v5 + 1) >> 1; + v5 = (v7 - v5 + 1) >> 1; + v7 = t; + + // stage 2 + t = (v0 - v3 + 1) >> 1; + v0 = (v0 + v3 + 1) >> 1; + v3 = t; + t = (v1 - v2 + 1) >> 1; + v1 = (v1 + v2 + 1) >> 1; + v2 = t; + t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; + v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; + v7 = t; + t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; + v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; + v6 = t; + + // stage 1 + p[0 + row] = v0 + v7; + p[7 + row] = v0 - v7; + p[1 + row] = v1 + v6; + p[6 + row] = v1 - v6; + p[2 + row] = v2 + v5; + p[5 + row] = v2 - v5; + p[3 + row] = v3 + v4; + p[4 + row] = v3 - v4; + } + + // inverse DCT on columns + for (i = 0; i < 8; ++i) { + var col = i; + + // check for all-zero AC coefficients + if (p[1*8 + col] == 0 && p[2*8 + col] == 0 && p[3*8 + col] == 0 && + p[4*8 + col] == 0 && p[5*8 + col] == 0 && p[6*8 + col] == 0 && + p[7*8 + col] == 0) { + t = (dctSqrt2 * dataIn[i+0] + 8192) >> 14; + p[0*8 + col] = t; + p[1*8 + col] = t; + p[2*8 + col] = t; + p[3*8 + col] = t; + p[4*8 + col] = t; + p[5*8 + col] = t; + p[6*8 + col] = t; + p[7*8 + col] = t; + continue; + } + + // stage 4 + v0 = (dctSqrt2 * p[0*8 + col] + 2048) >> 12; + v1 = (dctSqrt2 * p[4*8 + col] + 2048) >> 12; + v2 = p[2*8 + col]; + v3 = p[6*8 + col]; + v4 = (dctSqrt1d2 * (p[1*8 + col] - p[7*8 + col]) + 2048) >> 12; + v7 = (dctSqrt1d2 * (p[1*8 + col] + p[7*8 + col]) + 2048) >> 12; + v5 = p[3*8 + col]; + v6 = p[5*8 + col]; + + // stage 3 + t = (v0 - v1 + 1) >> 1; + v0 = (v0 + v1 + 1) >> 1; + v1 = t; + t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12; + v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12; + v3 = t; + t = (v4 - v6 + 1) >> 1; + v4 = (v4 + v6 + 1) >> 1; + v6 = t; + t = (v7 + v5 + 1) >> 1; + v5 = (v7 - v5 + 1) >> 1; + v7 = t; + + // stage 2 + t = (v0 - v3 + 1) >> 1; + v0 = (v0 + v3 + 1) >> 1; + v3 = t; + t = (v1 - v2 + 1) >> 1; + v1 = (v1 + v2 + 1) >> 1; + v2 = t; + t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; + v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; + v7 = t; + t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; + v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; + v6 = t; + + // stage 1 + p[0*8 + col] = v0 + v7; + p[7*8 + col] = v0 - v7; + p[1*8 + col] = v1 + v6; + p[6*8 + col] = v1 - v6; + p[2*8 + col] = v2 + v5; + p[5*8 + col] = v2 - v5; + p[3*8 + col] = v3 + v4; + p[4*8 + col] = v3 - v4; + } + + // convert to 8-bit integers + for (i = 0; i < 64; ++i) { + var sample = 128 + ((p[i] + 8) >> 4); + dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample; + } + } + + var i, j; + for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) { + var scanLine = blockRow << 3; + for (i = 0; i < 8; i++) + lines.push(new Uint8Array(samplesPerLine)); + for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) { + quantizeAndInverse(component.blocks[blockRow][blockCol], r, R); + + var offset = 0, sample = blockCol << 3; + for (j = 0; j < 8; j++) { + var line = lines[scanLine + j]; + for (i = 0; i < 8; i++) + line[sample + i] = r[offset++]; + } + } + } + return lines; + } + + function clampTo8bit(a) { + return a < 0 ? 0 : a > 255 ? 255 : a; + } + + constructor.prototype = { + load: function load(path) { + var xhr = new XMLHttpRequest(); + xhr.open("GET", path, true); + xhr.responseType = "arraybuffer"; + xhr.onload = (function() { + // TODO catch parse error + var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer); + this.parse(data); + if (this.onload) + this.onload(); + }).bind(this); + xhr.send(null); + }, + parse: function parse(data) { + var offset = 0, length = data.length; + function readUint16() { + var value = (data[offset] << 8) | data[offset + 1]; + offset += 2; + return value; + } + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + function prepareComponents(frame) { + var maxH = 0, maxV = 0; + var component, componentId; + for (componentId in frame.components) { + if (frame.components.hasOwnProperty(componentId)) { + component = frame.components[componentId]; + if (maxH < component.h) maxH = component.h; + if (maxV < component.v) maxV = component.v; + } + } + var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH); + var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV); + for (componentId in frame.components) { + if (frame.components.hasOwnProperty(componentId)) { + component = frame.components[componentId]; + var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH); + var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + var blocks = []; + for (var i = 0; i < blocksPerColumnForMcu; i++) { + var row = []; + for (var j = 0; j < blocksPerLineForMcu; j++) + row.push(new Int32Array(64)); + blocks.push(row); + } + component.blocksPerLine = blocksPerLine; + component.blocksPerColumn = blocksPerColumn; + component.blocks = blocks; + } + } + frame.maxH = maxH; + frame.maxV = maxV; + frame.mcusPerLine = mcusPerLine; + frame.mcusPerColumn = mcusPerColumn; + } + var jfif = null; + var adobe = null; + var pixels = null; + var frame, resetInterval; + var quantizationTables = [], frames = []; + var huffmanTablesAC = [], huffmanTablesDC = []; + var fileMarker = readUint16(); + if (fileMarker != 0xFFD8) { // SOI (Start of Image) + throw "SOI not found"; + } + + fileMarker = readUint16(); + while (fileMarker != 0xFFD9) { // EOI (End of image) + var i, j, l; + switch(fileMarker) { + case 0xFF00: break; + case 0xFFE0: // APP0 (Application Specific) + case 0xFFE1: // APP1 + case 0xFFE2: // APP2 + case 0xFFE3: // APP3 + case 0xFFE4: // APP4 + case 0xFFE5: // APP5 + case 0xFFE6: // APP6 + case 0xFFE7: // APP7 + case 0xFFE8: // APP8 + case 0xFFE9: // APP9 + case 0xFFEA: // APP10 + case 0xFFEB: // APP11 + case 0xFFEC: // APP12 + case 0xFFED: // APP13 + case 0xFFEE: // APP14 + case 0xFFEF: // APP15 + case 0xFFFE: // COM (Comment) + var appData = readDataBlock(); + + if (fileMarker === 0xFFE0) { + if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 && + appData[3] === 0x46 && appData[4] === 0) { // 'JFIF\x00' + jfif = { + version: { major: appData[5], minor: appData[6] }, + densityUnits: appData[7], + xDensity: (appData[8] << 8) | appData[9], + yDensity: (appData[10] << 8) | appData[11], + thumbWidth: appData[12], + thumbHeight: appData[13], + thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13]) + }; + } + } + // TODO APP1 - Exif + if (fileMarker === 0xFFEE) { + if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F && + appData[3] === 0x62 && appData[4] === 0x65 && appData[5] === 0) { // 'Adobe\x00' + adobe = { + version: appData[6], + flags0: (appData[7] << 8) | appData[8], + flags1: (appData[9] << 8) | appData[10], + transformCode: appData[11] + }; + } + } + break; + + case 0xFFDB: // DQT (Define Quantization Tables) + var quantizationTablesLength = readUint16(); + var quantizationTablesEnd = quantizationTablesLength + offset - 2; + while (offset < quantizationTablesEnd) { + var quantizationTableSpec = data[offset++]; + var tableData = new Int32Array(64); + if ((quantizationTableSpec >> 4) === 0) { // 8 bit values + for (j = 0; j < 64; j++) { + var z = dctZigZag[j]; + tableData[z] = data[offset++]; + } + } else if ((quantizationTableSpec >> 4) === 1) { //16 bit + for (j = 0; j < 64; j++) { + var z = dctZigZag[j]; + tableData[z] = readUint16(); + } + } else + throw "DQT: invalid table spec"; + quantizationTables[quantizationTableSpec & 15] = tableData; + } + break; + + case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT) + case 0xFFC1: // SOF1 (Start of Frame, Extended DCT) + case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT) + readUint16(); // skip data length + frame = {}; + frame.extended = (fileMarker === 0xFFC1); + frame.progressive = (fileMarker === 0xFFC2); + frame.precision = data[offset++]; + frame.scanLines = readUint16(); + frame.samplesPerLine = readUint16(); + frame.components = {}; + frame.componentsOrder = []; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + var qId = data[offset + 2]; + frame.componentsOrder.push(componentId); + frame.components[componentId] = { + h: h, + v: v, + quantizationTable: quantizationTables[qId] + }; + offset += 3; + } + prepareComponents(frame); + frames.push(frame); + break; + + case 0xFFC4: // DHT (Define Huffman Tables) + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength;) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) + codeLengthSum += (codeLengths[j] = data[offset]); + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) + huffmanValues[j] = data[offset]; + i += 17 + codeLengthSum; + + ((huffmanTableSpec >> 4) === 0 ? + huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = + buildHuffmanTable(codeLengths, huffmanValues); + } + break; + + case 0xFFDD: // DRI (Define Restart Interval) + readUint16(); // skip data length + resetInterval = readUint16(); + break; + + case 0xFFDA: // SOS (Start of Scan) + var scanLength = readUint16(); + var selectorsCount = data[offset++]; + var components = [], component; + for (i = 0; i < selectorsCount; i++) { + component = frame.components[data[offset++]]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, + frame, components, resetInterval, + spectralStart, spectralEnd, + successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + break; + default: + if (data[offset - 3] == 0xFF && + data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) { + // could be incorrect encoding -- last 0xFF byte of the previous + // block was eaten by the encoder + offset -= 3; + break; + } + throw "unknown JPEG marker " + fileMarker.toString(16); + } + fileMarker = readUint16(); + } + if (frames.length != 1) + throw "only single frame JPEGs supported"; + + this.width = frame.samplesPerLine; + this.height = frame.scanLines; + this.jfif = jfif; + this.adobe = adobe; + this.components = []; + for (var i = 0; i < frame.componentsOrder.length; i++) { + var component = frame.components[frame.componentsOrder[i]]; + this.components.push({ + lines: buildComponentData(frame, component), + scaleX: component.h / frame.maxH, + scaleY: component.v / frame.maxV + }); + } + }, + getData: function getData(width, height) { + var scaleX = this.width / width, scaleY = this.height / height; + + var component1, component2, component3, component4; + var component1Line, component2Line, component3Line, component4Line; + var x, y; + var offset = 0; + var Y, Cb, Cr, K, C, M, Ye, R, G, B; + var colorTransform; + var dataLength = width * height * this.components.length; + var data = new Uint8Array(dataLength); + switch (this.components.length) { + case 1: + component1 = this.components[0]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + + data[offset++] = Y; + } + } + break; + case 2: + // PDF might compress two component data in custom colorspace + component1 = this.components[0]; + component2 = this.components[1]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + data[offset++] = Y; + Y = component2Line[0 | (x * component2.scaleX * scaleX)]; + data[offset++] = Y; + } + } + break; + case 3: + // The default transform for three components is true + colorTransform = true; + // The adobe transform marker overrides any previous setting + if (this.adobe && this.adobe.transformCode) + colorTransform = true; + else if (typeof this.colorTransform !== 'undefined') + colorTransform = !!this.colorTransform; + + component1 = this.components[0]; + component2 = this.components[1]; + component3 = this.components[2]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; + component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + if (!colorTransform) { + R = component1Line[0 | (x * component1.scaleX * scaleX)]; + G = component2Line[0 | (x * component2.scaleX * scaleX)]; + B = component3Line[0 | (x * component3.scaleX * scaleX)]; + } else { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + Cb = component2Line[0 | (x * component2.scaleX * scaleX)]; + Cr = component3Line[0 | (x * component3.scaleX * scaleX)]; + + R = clampTo8bit(Y + 1.402 * (Cr - 128)); + G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128)); + B = clampTo8bit(Y + 1.772 * (Cb - 128)); + } + + data[offset++] = R; + data[offset++] = G; + data[offset++] = B; + } + } + break; + case 4: + if (!this.adobe) + throw 'Unsupported color mode (4 components)'; + // The default transform for four components is false + colorTransform = false; + // The adobe transform marker overrides any previous setting + if (this.adobe && this.adobe.transformCode) + colorTransform = true; + else if (typeof this.colorTransform !== 'undefined') + colorTransform = !!this.colorTransform; + + component1 = this.components[0]; + component2 = this.components[1]; + component3 = this.components[2]; + component4 = this.components[3]; + for (y = 0; y < height; y++) { + component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]; + component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]; + component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]; + component4Line = component4.lines[0 | (y * component4.scaleY * scaleY)]; + for (x = 0; x < width; x++) { + if (!colorTransform) { + C = component1Line[0 | (x * component1.scaleX * scaleX)]; + M = component2Line[0 | (x * component2.scaleX * scaleX)]; + Ye = component3Line[0 | (x * component3.scaleX * scaleX)]; + K = component4Line[0 | (x * component4.scaleX * scaleX)]; + } else { + Y = component1Line[0 | (x * component1.scaleX * scaleX)]; + Cb = component2Line[0 | (x * component2.scaleX * scaleX)]; + Cr = component3Line[0 | (x * component3.scaleX * scaleX)]; + K = component4Line[0 | (x * component4.scaleX * scaleX)]; + + C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128)); + M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128)); + Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128)); + } + data[offset++] = C; + data[offset++] = M; + data[offset++] = Ye; + data[offset++] = K; + } + } + break; + default: + throw 'Unsupported color mode'; + } + return data; + }, + copyToImageData: function copyToImageData(imageData) { + var width = imageData.width, height = imageData.height; + var imageDataArray = imageData.data; + var data = this.getData(width, height); + var i = 0, j = 0, x, y; + var Y, K, C, M, R, G, B; + switch (this.components.length) { + case 1: + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + Y = data[i++]; + + imageDataArray[j++] = Y; + imageDataArray[j++] = Y; + imageDataArray[j++] = Y; + imageDataArray[j++] = 255; + } + } + break; + case 3: + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + R = data[i++]; + G = data[i++]; + B = data[i++]; + + imageDataArray[j++] = R; + imageDataArray[j++] = G; + imageDataArray[j++] = B; + imageDataArray[j++] = 255; + } + } + break; + case 4: + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + C = data[i++]; + M = data[i++]; + Y = data[i++]; + K = data[i++]; + + R = 255 - clampTo8bit(C * (1 - K / 255) + K); + G = 255 - clampTo8bit(M * (1 - K / 255) + K); + B = 255 - clampTo8bit(Y * (1 - K / 255) + K); + + imageDataArray[j++] = R; + imageDataArray[j++] = G; + imageDataArray[j++] = B; + imageDataArray[j++] = 255; + } + } + break; + default: + throw 'Unsupported color mode'; + } + } + }; + + return constructor; +})(); +module.exports = decode; + +function decode(jpegData) { + var arr = new Uint8Array(jpegData); + var decoder = new JpegImage(); + decoder.parse(arr); + var data = decoder.getData(decoder.width, decoder.height); + var buf = new Buffer(decoder.width * decoder.height * 4); + var n = 0; + for (var i = 0; i < buf.length; i++) { + buf[i + (i/3 | 0)] = data[n++]; + if (i % 4 == 3) buf[i] = 255; + } + return { + data: buf, + width: decoder.width, + height: decoder.height + }; +} + +}).call(this,require("buffer").Buffer) +},{"buffer":5}],137:[function(require,module,exports){ +arguments[4][69][0].apply(exports,arguments) +},{"buffer":5,"dup":69}],138:[function(require,module,exports){ +(function (Buffer){ +'use strict' + +var ContentStream = require('contentstream') +var GifEncoder = require('gif-encoder') +var jpegJs = require('jpeg-js') +var PNG = require('pngjs-nozlib').PNG +var ndarray = require('ndarray') +var ops = require('ndarray-ops') +var through = require('through') + +function handleData (array, data, frame) { + var i, j, ptr = 0, c + if (array.shape.length === 4) { + return handleData(array.pick(frame), data, 0) + } else if (array.shape.length === 3) { + if (array.shape[2] === 3) { + ops.assign( + ndarray(data, + [array.shape[0], array.shape[1], 3], + [4, 4 * array.shape[0], 1]), + array) + ops.assigns( + ndarray(data, + [array.shape[0] * array.shape[1]], + [4], + 3), + 255) + } else if (array.shape[2] === 4) { + ops.assign( + ndarray(data, + [array.shape[0], array.shape[1], 4], + [4, array.shape[0] * 4, 1]), + array) + } else if (array.shape[2] === 1) { + ops.assign( + ndarray(data, + [array.shape[0], array.shape[1], 3], + [4, 4 * array.shape[0], 1]), + ndarray(array.data, + [array.shape[0], array.shape[1], 3], + [array.stride[0], array.stride[1], 0], + array.offset)) + ops.assigns( + ndarray(data, + [array.shape[0] * array.shape[1]], + [4], + 3), + 255) + } else { + return new Error('Incompatible array shape') + } + } else if (array.shape.length === 2) { + ops.assign( + ndarray(data, + [array.shape[0], array.shape[1], 3], + [4, 4 * array.shape[0], 1]), + ndarray(array.data, + [array.shape[0], array.shape[1], 3], + [array.stride[0], array.stride[1], 0], + array.offset)) + ops.assigns( + ndarray(data, + [array.shape[0] * array.shape[1]], + [4], + 3), + 255) + } else { + return new Error('Incompatible array shape') + } + return data +} + +function haderror (err) { + var result = through() + result.emit('error', err) + return result +} + +module.exports = function savePixels (array, type, options) { + options = options || {} + switch (type.toUpperCase()) { + case 'JPG': + case '.JPG': + case 'JPEG': + case '.JPEG': + case 'JPE': + case '.JPE': + var width = array.shape[0] + var height = array.shape[1] + var data = new Buffer(width * height * 4) + data = handleData(array, data) + var rawImageData = { + data: data, + width: width, + height: height + } + var jpegImageData = jpegJs.encode(rawImageData, options.quality) + return new ContentStream(jpegImageData.data) + + case 'GIF': + case '.GIF': + var frames = array.shape.length === 4 ? array.shape[0] : 1 + var width = array.shape.length === 4 ? array.shape[1] : array.shape[0] + var height = array.shape.length === 4 ? array.shape[2] : array.shape[1] + var data = new Buffer(width * height * 4) + var gif = new GifEncoder(width, height) + gif.writeHeader() + for (var i = 0; i < frames; i++) { + data = handleData(array, data, i) + gif.addFrame(data) + } + gif.finish() + return gif + + case 'PNG': + case '.PNG': + var png = new PNG({ + width: array.shape[0], + height: array.shape[1] + }) + var data = handleData(array, png.data) + if (typeof data === 'Error') return haderror(data) + png.data = data + return png.pack() + + case 'CANVAS': + var canvas = document.createElement('canvas') + var context = canvas.getContext('2d') + canvas.width = array.shape[0] + canvas.height = array.shape[1] + var imageData = context.getImageData(0, 0, canvas.width, canvas.height) + var data = imageData.data + data = handleData(array, data) + if (typeof data === 'Error') return haderror(data) + context.putImageData(imageData, 0, 0) + return canvas + + default: + return haderror(new Error('Unsupported file type: ' + type)) + } +} + +}).call(this,require("buffer").Buffer) +},{"buffer":5,"contentstream":8,"gif-encoder":32,"jpeg-js":135,"ndarray":84,"ndarray-ops":81,"pngjs-nozlib":115,"through":141}],139:[function(require,module,exports){ +// 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. + +module.exports = Stream; + +var EE = require('events').EventEmitter; +var inherits = require('inherits'); + +inherits(Stream, EE); +Stream.Readable = require('readable-stream/readable.js'); +Stream.Writable = require('readable-stream/writable.js'); +Stream.Duplex = require('readable-stream/duplex.js'); +Stream.Transform = require('readable-stream/transform.js'); +Stream.PassThrough = require('readable-stream/passthrough.js'); + +// Backwards-compat with node 0.4.x +Stream.Stream = 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; +}; + +},{"events":48,"inherits":70,"readable-stream/duplex.js":118,"readable-stream/passthrough.js":130,"readable-stream/readable.js":131,"readable-stream/transform.js":132,"readable-stream/writable.js":133}],140:[function(require,module,exports){ +// 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. + +var Buffer = require('buffer').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. +var StringDecoder = exports.StringDecoder = function(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; +} + +},{"buffer":5}],141:[function(require,module,exports){ (function (process){ var Stream = require('stream') @@ -46938,7 +55847,7 @@ function through (write, end, opts) { }).call(this,require('_process')) -},{"_process":98,"stream":112}],128:[function(require,module,exports){ +},{"_process":117,"stream":139}],142:[function(require,module,exports){ (function (setImmediate,clearImmediate){ var nextTick = require('process/browser.js').nextTick; var apply = Function.prototype.apply; @@ -47017,7 +55926,7 @@ exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : delete immediateIds[id]; }; }).call(this,require("timers").setImmediate,require("timers").clearImmediate) -},{"process/browser.js":98,"timers":128}],129:[function(require,module,exports){ +},{"process/browser.js":117,"timers":142}],143:[function(require,module,exports){ exports.isatty = function () { return false; }; function ReadStream() { @@ -47030,7 +55939,7 @@ function WriteStream() { } exports.WriteStream = WriteStream; -},{}],130:[function(require,module,exports){ +},{}],144:[function(require,module,exports){ (function (global,Buffer){ 'use strict' @@ -47247,7 +56156,1235 @@ exports.clearCache = function clearCache() { } } }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer) -},{"bit-twiddle":2,"buffer":4,"dup":14}],131:[function(require,module,exports){ +},{"bit-twiddle":2,"buffer":5,"dup":21}],145:[function(require,module,exports){ +// Underscore.js 1.4.4 +// http://underscorejs.org +// (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc. +// Underscore may be freely distributed under the MIT license. + +(function() { + + // Baseline setup + // -------------- + + // Establish the root object, `window` in the browser, or `global` on the server. + var root = this; + + // Save the previous value of the `_` variable. + var previousUnderscore = root._; + + // Establish the object that gets returned to break out of a loop iteration. + var breaker = {}; + + // Save bytes in the minified (but not gzipped) version: + var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype; + + // Create quick reference variables for speed access to core prototypes. + var push = ArrayProto.push, + slice = ArrayProto.slice, + concat = ArrayProto.concat, + toString = ObjProto.toString, + hasOwnProperty = ObjProto.hasOwnProperty; + + // All **ECMAScript 5** native function implementations that we hope to use + // are declared here. + var + nativeForEach = ArrayProto.forEach, + nativeMap = ArrayProto.map, + nativeReduce = ArrayProto.reduce, + nativeReduceRight = ArrayProto.reduceRight, + nativeFilter = ArrayProto.filter, + nativeEvery = ArrayProto.every, + nativeSome = ArrayProto.some, + nativeIndexOf = ArrayProto.indexOf, + nativeLastIndexOf = ArrayProto.lastIndexOf, + nativeIsArray = Array.isArray, + nativeKeys = Object.keys, + nativeBind = FuncProto.bind; + + // Create a safe reference to the Underscore object for use below. + var _ = function(obj) { + if (obj instanceof _) return obj; + if (!(this instanceof _)) return new _(obj); + this._wrapped = obj; + }; + + // Export the Underscore object for **Node.js**, with + // backwards-compatibility for the old `require()` API. If we're in + // the browser, add `_` as a global object via a string identifier, + // for Closure Compiler "advanced" mode. + if (typeof exports !== 'undefined') { + if (typeof module !== 'undefined' && module.exports) { + exports = module.exports = _; + } + exports._ = _; + } else { + root._ = _; + } + + // Current version. + _.VERSION = '1.4.4'; + + // Collection Functions + // -------------------- + + // The cornerstone, an `each` implementation, aka `forEach`. + // Handles objects with the built-in `forEach`, arrays, and raw objects. + // Delegates to **ECMAScript 5**'s native `forEach` if available. + var each = _.each = _.forEach = function(obj, iterator, context) { + if (obj == null) return; + if (nativeForEach && obj.forEach === nativeForEach) { + obj.forEach(iterator, context); + } else if (obj.length === +obj.length) { + for (var i = 0, l = obj.length; i < l; i++) { + if (iterator.call(context, obj[i], i, obj) === breaker) return; + } + } else { + for (var key in obj) { + if (_.has(obj, key)) { + if (iterator.call(context, obj[key], key, obj) === breaker) return; + } + } + } + }; + + // Return the results of applying the iterator to each element. + // Delegates to **ECMAScript 5**'s native `map` if available. + _.map = _.collect = function(obj, iterator, context) { + var results = []; + if (obj == null) return results; + if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context); + each(obj, function(value, index, list) { + results[results.length] = iterator.call(context, value, index, list); + }); + return results; + }; + + var reduceError = 'Reduce of empty array with no initial value'; + + // **Reduce** builds up a single result from a list of values, aka `inject`, + // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available. + _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) { + var initial = arguments.length > 2; + if (obj == null) obj = []; + if (nativeReduce && obj.reduce === nativeReduce) { + if (context) iterator = _.bind(iterator, context); + return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator); + } + each(obj, function(value, index, list) { + if (!initial) { + memo = value; + initial = true; + } else { + memo = iterator.call(context, memo, value, index, list); + } + }); + if (!initial) throw new TypeError(reduceError); + return memo; + }; + + // The right-associative version of reduce, also known as `foldr`. + // Delegates to **ECMAScript 5**'s native `reduceRight` if available. + _.reduceRight = _.foldr = function(obj, iterator, memo, context) { + var initial = arguments.length > 2; + if (obj == null) obj = []; + if (nativeReduceRight && obj.reduceRight === nativeReduceRight) { + if (context) iterator = _.bind(iterator, context); + return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator); + } + var length = obj.length; + if (length !== +length) { + var keys = _.keys(obj); + length = keys.length; + } + each(obj, function(value, index, list) { + index = keys ? keys[--length] : --length; + if (!initial) { + memo = obj[index]; + initial = true; + } else { + memo = iterator.call(context, memo, obj[index], index, list); + } + }); + if (!initial) throw new TypeError(reduceError); + return memo; + }; + + // Return the first value which passes a truth test. Aliased as `detect`. + _.find = _.detect = function(obj, iterator, context) { + var result; + any(obj, function(value, index, list) { + if (iterator.call(context, value, index, list)) { + result = value; + return true; + } + }); + return result; + }; + + // Return all the elements that pass a truth test. + // Delegates to **ECMAScript 5**'s native `filter` if available. + // Aliased as `select`. + _.filter = _.select = function(obj, iterator, context) { + var results = []; + if (obj == null) return results; + if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context); + each(obj, function(value, index, list) { + if (iterator.call(context, value, index, list)) results[results.length] = value; + }); + return results; + }; + + // Return all the elements for which a truth test fails. + _.reject = function(obj, iterator, context) { + return _.filter(obj, function(value, index, list) { + return !iterator.call(context, value, index, list); + }, context); + }; + + // Determine whether all of the elements match a truth test. + // Delegates to **ECMAScript 5**'s native `every` if available. + // Aliased as `all`. + _.every = _.all = function(obj, iterator, context) { + iterator || (iterator = _.identity); + var result = true; + if (obj == null) return result; + if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context); + each(obj, function(value, index, list) { + if (!(result = result && iterator.call(context, value, index, list))) return breaker; + }); + return !!result; + }; + + // Determine if at least one element in the object matches a truth test. + // Delegates to **ECMAScript 5**'s native `some` if available. + // Aliased as `any`. + var any = _.some = _.any = function(obj, iterator, context) { + iterator || (iterator = _.identity); + var result = false; + if (obj == null) return result; + if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context); + each(obj, function(value, index, list) { + if (result || (result = iterator.call(context, value, index, list))) return breaker; + }); + return !!result; + }; + + // Determine if the array or object contains a given value (using `===`). + // Aliased as `include`. + _.contains = _.include = function(obj, target) { + if (obj == null) return false; + if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1; + return any(obj, function(value) { + return value === target; + }); + }; + + // Invoke a method (with arguments) on every item in a collection. + _.invoke = function(obj, method) { + var args = slice.call(arguments, 2); + var isFunc = _.isFunction(method); + return _.map(obj, function(value) { + return (isFunc ? method : value[method]).apply(value, args); + }); + }; + + // Convenience version of a common use case of `map`: fetching a property. + _.pluck = function(obj, key) { + return _.map(obj, function(value){ return value[key]; }); + }; + + // Convenience version of a common use case of `filter`: selecting only objects + // containing specific `key:value` pairs. + _.where = function(obj, attrs, first) { + if (_.isEmpty(attrs)) return first ? null : []; + return _[first ? 'find' : 'filter'](obj, function(value) { + for (var key in attrs) { + if (attrs[key] !== value[key]) return false; + } + return true; + }); + }; + + // Convenience version of a common use case of `find`: getting the first object + // containing specific `key:value` pairs. + _.findWhere = function(obj, attrs) { + return _.where(obj, attrs, true); + }; + + // Return the maximum element or (element-based computation). + // Can't optimize arrays of integers longer than 65,535 elements. + // See: https://bugs.webkit.org/show_bug.cgi?id=80797 + _.max = function(obj, iterator, context) { + if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) { + return Math.max.apply(Math, obj); + } + if (!iterator && _.isEmpty(obj)) return -Infinity; + var result = {computed : -Infinity, value: -Infinity}; + each(obj, function(value, index, list) { + var computed = iterator ? iterator.call(context, value, index, list) : value; + computed >= result.computed && (result = {value : value, computed : computed}); + }); + return result.value; + }; + + // Return the minimum element (or element-based computation). + _.min = function(obj, iterator, context) { + if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) { + return Math.min.apply(Math, obj); + } + if (!iterator && _.isEmpty(obj)) return Infinity; + var result = {computed : Infinity, value: Infinity}; + each(obj, function(value, index, list) { + var computed = iterator ? iterator.call(context, value, index, list) : value; + computed < result.computed && (result = {value : value, computed : computed}); + }); + return result.value; + }; + + // Shuffle an array. + _.shuffle = function(obj) { + var rand; + var index = 0; + var shuffled = []; + each(obj, function(value) { + rand = _.random(index++); + shuffled[index - 1] = shuffled[rand]; + shuffled[rand] = value; + }); + return shuffled; + }; + + // An internal function to generate lookup iterators. + var lookupIterator = function(value) { + return _.isFunction(value) ? value : function(obj){ return obj[value]; }; + }; + + // Sort the object's values by a criterion produced by an iterator. + _.sortBy = function(obj, value, context) { + var iterator = lookupIterator(value); + return _.pluck(_.map(obj, function(value, index, list) { + return { + value : value, + index : index, + criteria : iterator.call(context, value, index, list) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || a === void 0) return 1; + if (a < b || b === void 0) return -1; + } + return left.index < right.index ? -1 : 1; + }), 'value'); + }; + + // An internal function used for aggregate "group by" operations. + var group = function(obj, value, context, behavior) { + var result = {}; + var iterator = lookupIterator(value || _.identity); + each(obj, function(value, index) { + var key = iterator.call(context, value, index, obj); + behavior(result, key, value); + }); + return result; + }; + + // Groups the object's values by a criterion. Pass either a string attribute + // to group by, or a function that returns the criterion. + _.groupBy = function(obj, value, context) { + return group(obj, value, context, function(result, key, value) { + (_.has(result, key) ? result[key] : (result[key] = [])).push(value); + }); + }; + + // Counts instances of an object that group by a certain criterion. Pass + // either a string attribute to count by, or a function that returns the + // criterion. + _.countBy = function(obj, value, context) { + return group(obj, value, context, function(result, key) { + if (!_.has(result, key)) result[key] = 0; + result[key]++; + }); + }; + + // Use a comparator function to figure out the smallest index at which + // an object should be inserted so as to maintain order. Uses binary search. + _.sortedIndex = function(array, obj, iterator, context) { + iterator = iterator == null ? _.identity : lookupIterator(iterator); + var value = iterator.call(context, obj); + var low = 0, high = array.length; + while (low < high) { + var mid = (low + high) >>> 1; + iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid; + } + return low; + }; + + // Safely convert anything iterable into a real, live array. + _.toArray = function(obj) { + if (!obj) return []; + if (_.isArray(obj)) return slice.call(obj); + if (obj.length === +obj.length) return _.map(obj, _.identity); + return _.values(obj); + }; + + // Return the number of elements in an object. + _.size = function(obj) { + if (obj == null) return 0; + return (obj.length === +obj.length) ? obj.length : _.keys(obj).length; + }; + + // Array Functions + // --------------- + + // Get the first element of an array. Passing **n** will return the first N + // values in the array. Aliased as `head` and `take`. The **guard** check + // allows it to work with `_.map`. + _.first = _.head = _.take = function(array, n, guard) { + if (array == null) return void 0; + return (n != null) && !guard ? slice.call(array, 0, n) : array[0]; + }; + + // Returns everything but the last entry of the array. Especially useful on + // the arguments object. Passing **n** will return all the values in + // the array, excluding the last N. The **guard** check allows it to work with + // `_.map`. + _.initial = function(array, n, guard) { + return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n)); + }; + + // Get the last element of an array. Passing **n** will return the last N + // values in the array. The **guard** check allows it to work with `_.map`. + _.last = function(array, n, guard) { + if (array == null) return void 0; + if ((n != null) && !guard) { + return slice.call(array, Math.max(array.length - n, 0)); + } else { + return array[array.length - 1]; + } + }; + + // Returns everything but the first entry of the array. Aliased as `tail` and `drop`. + // Especially useful on the arguments object. Passing an **n** will return + // the rest N values in the array. The **guard** + // check allows it to work with `_.map`. + _.rest = _.tail = _.drop = function(array, n, guard) { + return slice.call(array, (n == null) || guard ? 1 : n); + }; + + // Trim out all falsy values from an array. + _.compact = function(array) { + return _.filter(array, _.identity); + }; + + // Internal implementation of a recursive `flatten` function. + var flatten = function(input, shallow, output) { + each(input, function(value) { + if (_.isArray(value)) { + shallow ? push.apply(output, value) : flatten(value, shallow, output); + } else { + output.push(value); + } + }); + return output; + }; + + // Return a completely flattened version of an array. + _.flatten = function(array, shallow) { + return flatten(array, shallow, []); + }; + + // Return a version of the array that does not contain the specified value(s). + _.without = function(array) { + return _.difference(array, slice.call(arguments, 1)); + }; + + // Produce a duplicate-free version of the array. If the array has already + // been sorted, you have the option of using a faster algorithm. + // Aliased as `unique`. + _.uniq = _.unique = function(array, isSorted, iterator, context) { + if (_.isFunction(isSorted)) { + context = iterator; + iterator = isSorted; + isSorted = false; + } + var initial = iterator ? _.map(array, iterator, context) : array; + var results = []; + var seen = []; + each(initial, function(value, index) { + if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) { + seen.push(value); + results.push(array[index]); + } + }); + return results; + }; + + // Produce an array that contains the union: each distinct element from all of + // the passed-in arrays. + _.union = function() { + return _.uniq(concat.apply(ArrayProto, arguments)); + }; + + // Produce an array that contains every item shared between all the + // passed-in arrays. + _.intersection = function(array) { + var rest = slice.call(arguments, 1); + return _.filter(_.uniq(array), function(item) { + return _.every(rest, function(other) { + return _.indexOf(other, item) >= 0; + }); + }); + }; + + // Take the difference between one array and a number of other arrays. + // Only the elements present in just the first array will remain. + _.difference = function(array) { + var rest = concat.apply(ArrayProto, slice.call(arguments, 1)); + return _.filter(array, function(value){ return !_.contains(rest, value); }); + }; + + // Zip together multiple lists into a single array -- elements that share + // an index go together. + _.zip = function() { + var args = slice.call(arguments); + var length = _.max(_.pluck(args, 'length')); + var results = new Array(length); + for (var i = 0; i < length; i++) { + results[i] = _.pluck(args, "" + i); + } + return results; + }; + + // Converts lists into objects. Pass either a single array of `[key, value]` + // pairs, or two parallel arrays of the same length -- one of keys, and one of + // the corresponding values. + _.object = function(list, values) { + if (list == null) return {}; + var result = {}; + for (var i = 0, l = list.length; i < l; i++) { + if (values) { + result[list[i]] = values[i]; + } else { + result[list[i][0]] = list[i][1]; + } + } + return result; + }; + + // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**), + // we need this function. Return the position of the first occurrence of an + // item in an array, or -1 if the item is not included in the array. + // Delegates to **ECMAScript 5**'s native `indexOf` if available. + // If the array is large and already in sort order, pass `true` + // for **isSorted** to use binary search. + _.indexOf = function(array, item, isSorted) { + if (array == null) return -1; + var i = 0, l = array.length; + if (isSorted) { + if (typeof isSorted == 'number') { + i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted); + } else { + i = _.sortedIndex(array, item); + return array[i] === item ? i : -1; + } + } + if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted); + for (; i < l; i++) if (array[i] === item) return i; + return -1; + }; + + // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available. + _.lastIndexOf = function(array, item, from) { + if (array == null) return -1; + var hasIndex = from != null; + if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) { + return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item); + } + var i = (hasIndex ? from : array.length); + while (i--) if (array[i] === item) return i; + return -1; + }; + + // Generate an integer Array containing an arithmetic progression. A port of + // the native Python `range()` function. See + // [the Python documentation](http://docs.python.org/library/functions.html#range). + _.range = function(start, stop, step) { + if (arguments.length <= 1) { + stop = start || 0; + start = 0; + } + step = arguments[2] || 1; + + var len = Math.max(Math.ceil((stop - start) / step), 0); + var idx = 0; + var range = new Array(len); + + while(idx < len) { + range[idx++] = start; + start += step; + } + + return range; + }; + + // Function (ahem) Functions + // ------------------ + + // Create a function bound to a given object (assigning `this`, and arguments, + // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if + // available. + _.bind = function(func, context) { + if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); + var args = slice.call(arguments, 2); + return function() { + return func.apply(context, args.concat(slice.call(arguments))); + }; + }; + + // Partially apply a function by creating a version that has had some of its + // arguments pre-filled, without changing its dynamic `this` context. + _.partial = function(func) { + var args = slice.call(arguments, 1); + return function() { + return func.apply(this, args.concat(slice.call(arguments))); + }; + }; + + // Bind all of an object's methods to that object. Useful for ensuring that + // all callbacks defined on an object belong to it. + _.bindAll = function(obj) { + var funcs = slice.call(arguments, 1); + if (funcs.length === 0) funcs = _.functions(obj); + each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); }); + return obj; + }; + + // Memoize an expensive function by storing its results. + _.memoize = function(func, hasher) { + var memo = {}; + hasher || (hasher = _.identity); + return function() { + var key = hasher.apply(this, arguments); + return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments)); + }; + }; + + // Delays a function for the given number of milliseconds, and then calls + // it with the arguments supplied. + _.delay = function(func, wait) { + var args = slice.call(arguments, 2); + return setTimeout(function(){ return func.apply(null, args); }, wait); + }; + + // Defers a function, scheduling it to run after the current call stack has + // cleared. + _.defer = function(func) { + return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1))); + }; + + // Returns a function, that, when invoked, will only be triggered at most once + // during a given window of time. + _.throttle = function(func, wait) { + var context, args, timeout, result; + var previous = 0; + var later = function() { + previous = new Date; + timeout = null; + result = func.apply(context, args); + }; + return function() { + var now = new Date; + var remaining = wait - (now - previous); + context = this; + args = arguments; + if (remaining <= 0) { + clearTimeout(timeout); + timeout = null; + previous = now; + result = func.apply(context, args); + } else if (!timeout) { + timeout = setTimeout(later, remaining); + } + return result; + }; + }; + + // Returns a function, that, as long as it continues to be invoked, will not + // be triggered. The function will be called after it stops being called for + // N milliseconds. If `immediate` is passed, trigger the function on the + // leading edge, instead of the trailing. + _.debounce = function(func, wait, immediate) { + var timeout, result; + return function() { + var context = this, args = arguments; + var later = function() { + timeout = null; + if (!immediate) result = func.apply(context, args); + }; + var callNow = immediate && !timeout; + clearTimeout(timeout); + timeout = setTimeout(later, wait); + if (callNow) result = func.apply(context, args); + return result; + }; + }; + + // Returns a function that will be executed at most one time, no matter how + // often you call it. Useful for lazy initialization. + _.once = function(func) { + var ran = false, memo; + return function() { + if (ran) return memo; + ran = true; + memo = func.apply(this, arguments); + func = null; + return memo; + }; + }; + + // Returns the first function passed as an argument to the second, + // allowing you to adjust arguments, run code before and after, and + // conditionally execute the original function. + _.wrap = function(func, wrapper) { + return function() { + var args = [func]; + push.apply(args, arguments); + return wrapper.apply(this, args); + }; + }; + + // Returns a function that is the composition of a list of functions, each + // consuming the return value of the function that follows. + _.compose = function() { + var funcs = arguments; + return function() { + var args = arguments; + for (var i = funcs.length - 1; i >= 0; i--) { + args = [funcs[i].apply(this, args)]; + } + return args[0]; + }; + }; + + // Returns a function that will only be executed after being called N times. + _.after = function(times, func) { + if (times <= 0) return func(); + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; + }; + + // Object Functions + // ---------------- + + // Retrieve the names of an object's properties. + // Delegates to **ECMAScript 5**'s native `Object.keys` + _.keys = nativeKeys || function(obj) { + if (obj !== Object(obj)) throw new TypeError('Invalid object'); + var keys = []; + for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key; + return keys; + }; + + // Retrieve the values of an object's properties. + _.values = function(obj) { + var values = []; + for (var key in obj) if (_.has(obj, key)) values.push(obj[key]); + return values; + }; + + // Convert an object into a list of `[key, value]` pairs. + _.pairs = function(obj) { + var pairs = []; + for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]); + return pairs; + }; + + // Invert the keys and values of an object. The values must be serializable. + _.invert = function(obj) { + var result = {}; + for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key; + return result; + }; + + // Return a sorted list of the function names available on the object. + // Aliased as `methods` + _.functions = _.methods = function(obj) { + var names = []; + for (var key in obj) { + if (_.isFunction(obj[key])) names.push(key); + } + return names.sort(); + }; + + // Extend a given object with all the properties in passed-in object(s). + _.extend = function(obj) { + each(slice.call(arguments, 1), function(source) { + if (source) { + for (var prop in source) { + obj[prop] = source[prop]; + } + } + }); + return obj; + }; + + // Return a copy of the object only containing the whitelisted properties. + _.pick = function(obj) { + var copy = {}; + var keys = concat.apply(ArrayProto, slice.call(arguments, 1)); + each(keys, function(key) { + if (key in obj) copy[key] = obj[key]; + }); + return copy; + }; + + // Return a copy of the object without the blacklisted properties. + _.omit = function(obj) { + var copy = {}; + var keys = concat.apply(ArrayProto, slice.call(arguments, 1)); + for (var key in obj) { + if (!_.contains(keys, key)) copy[key] = obj[key]; + } + return copy; + }; + + // Fill in a given object with default properties. + _.defaults = function(obj) { + each(slice.call(arguments, 1), function(source) { + if (source) { + for (var prop in source) { + if (obj[prop] == null) obj[prop] = source[prop]; + } + } + }); + return obj; + }; + + // Create a (shallow-cloned) duplicate of an object. + _.clone = function(obj) { + if (!_.isObject(obj)) return obj; + return _.isArray(obj) ? obj.slice() : _.extend({}, obj); + }; + + // Invokes interceptor with the obj, and then returns obj. + // The primary purpose of this method is to "tap into" a method chain, in + // order to perform operations on intermediate results within the chain. + _.tap = function(obj, interceptor) { + interceptor(obj); + return obj; + }; + + // Internal recursive comparison function for `isEqual`. + var eq = function(a, b, aStack, bStack) { + // Identical objects are equal. `0 === -0`, but they aren't identical. + // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal. + if (a === b) return a !== 0 || 1 / a == 1 / b; + // A strict comparison is necessary because `null == undefined`. + if (a == null || b == null) return a === b; + // Unwrap any wrapped objects. + if (a instanceof _) a = a._wrapped; + if (b instanceof _) b = b._wrapped; + // Compare `[[Class]]` names. + var className = toString.call(a); + if (className != toString.call(b)) return false; + switch (className) { + // Strings, numbers, dates, and booleans are compared by value. + case '[object String]': + // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is + // equivalent to `new String("5")`. + return a == String(b); + case '[object Number]': + // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for + // other numeric values. + return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b); + case '[object Date]': + case '[object Boolean]': + // Coerce dates and booleans to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a == +b; + // RegExps are compared by their source patterns and flags. + case '[object RegExp]': + return a.source == b.source && + a.global == b.global && + a.multiline == b.multiline && + a.ignoreCase == b.ignoreCase; + } + if (typeof a != 'object' || typeof b != 'object') return false; + // Assume equality for cyclic structures. The algorithm for detecting cyclic + // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. + var length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + if (aStack[length] == a) return bStack[length] == b; + } + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + var size = 0, result = true; + // Recursively compare objects and arrays. + if (className == '[object Array]') { + // Compare array lengths to determine if a deep comparison is necessary. + size = a.length; + result = size == b.length; + if (result) { + // Deep compare the contents, ignoring non-numeric properties. + while (size--) { + if (!(result = eq(a[size], b[size], aStack, bStack))) break; + } + } + } else { + // Objects with different constructors are not equivalent, but `Object`s + // from different frames are. + var aCtor = a.constructor, bCtor = b.constructor; + if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) && + _.isFunction(bCtor) && (bCtor instanceof bCtor))) { + return false; + } + // Deep compare objects. + for (var key in a) { + if (_.has(a, key)) { + // Count the expected number of properties. + size++; + // Deep compare each member. + if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break; + } + } + // Ensure that both objects contain the same number of properties. + if (result) { + for (key in b) { + if (_.has(b, key) && !(size--)) break; + } + result = !size; + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return result; + }; + + // Perform a deep comparison to check if two objects are equal. + _.isEqual = function(a, b) { + return eq(a, b, [], []); + }; + + // Is a given array, string, or object empty? + // An "empty" object has no enumerable own-properties. + _.isEmpty = function(obj) { + if (obj == null) return true; + if (_.isArray(obj) || _.isString(obj)) return obj.length === 0; + for (var key in obj) if (_.has(obj, key)) return false; + return true; + }; + + // Is a given value a DOM element? + _.isElement = function(obj) { + return !!(obj && obj.nodeType === 1); + }; + + // Is a given value an array? + // Delegates to ECMA5's native Array.isArray + _.isArray = nativeIsArray || function(obj) { + return toString.call(obj) == '[object Array]'; + }; + + // Is a given variable an object? + _.isObject = function(obj) { + return obj === Object(obj); + }; + + // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp. + each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) { + _['is' + name] = function(obj) { + return toString.call(obj) == '[object ' + name + ']'; + }; + }); + + // Define a fallback version of the method in browsers (ahem, IE), where + // there isn't any inspectable "Arguments" type. + if (!_.isArguments(arguments)) { + _.isArguments = function(obj) { + return !!(obj && _.has(obj, 'callee')); + }; + } + + // Optimize `isFunction` if appropriate. + if (typeof (/./) !== 'function') { + _.isFunction = function(obj) { + return typeof obj === 'function'; + }; + } + + // Is a given object a finite number? + _.isFinite = function(obj) { + return isFinite(obj) && !isNaN(parseFloat(obj)); + }; + + // Is the given value `NaN`? (NaN is the only number which does not equal itself). + _.isNaN = function(obj) { + return _.isNumber(obj) && obj != +obj; + }; + + // Is a given value a boolean? + _.isBoolean = function(obj) { + return obj === true || obj === false || toString.call(obj) == '[object Boolean]'; + }; + + // Is a given value equal to null? + _.isNull = function(obj) { + return obj === null; + }; + + // Is a given variable undefined? + _.isUndefined = function(obj) { + return obj === void 0; + }; + + // Shortcut function for checking if an object has a given property directly + // on itself (in other words, not on a prototype). + _.has = function(obj, key) { + return hasOwnProperty.call(obj, key); + }; + + // Utility Functions + // ----------------- + + // Run Underscore.js in *noConflict* mode, returning the `_` variable to its + // previous owner. Returns a reference to the Underscore object. + _.noConflict = function() { + root._ = previousUnderscore; + return this; + }; + + // Keep the identity function around for default iterators. + _.identity = function(value) { + return value; + }; + + // Run a function **n** times. + _.times = function(n, iterator, context) { + var accum = Array(n); + for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i); + return accum; + }; + + // Return a random integer between min and max (inclusive). + _.random = function(min, max) { + if (max == null) { + max = min; + min = 0; + } + return min + Math.floor(Math.random() * (max - min + 1)); + }; + + // List of HTML entities for escaping. + var entityMap = { + escape: { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '/': '/' + } + }; + entityMap.unescape = _.invert(entityMap.escape); + + // Regexes containing the keys and values listed immediately above. + var entityRegexes = { + escape: new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'), + unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g') + }; + + // Functions for escaping and unescaping strings to/from HTML interpolation. + _.each(['escape', 'unescape'], function(method) { + _[method] = function(string) { + if (string == null) return ''; + return ('' + string).replace(entityRegexes[method], function(match) { + return entityMap[method][match]; + }); + }; + }); + + // If the value of the named property is a function then invoke it; + // otherwise, return it. + _.result = function(object, property) { + if (object == null) return null; + var value = object[property]; + return _.isFunction(value) ? value.call(object) : value; + }; + + // Add your own custom functions to the Underscore object. + _.mixin = function(obj) { + each(_.functions(obj), function(name){ + var func = _[name] = obj[name]; + _.prototype[name] = function() { + var args = [this._wrapped]; + push.apply(args, arguments); + return result.call(this, func.apply(_, args)); + }; + }); + }; + + // Generate a unique integer id (unique within the entire client session). + // Useful for temporary DOM ids. + var idCounter = 0; + _.uniqueId = function(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; + }; + + // By default, Underscore uses ERB-style template delimiters, change the + // following template settings to use alternative delimiters. + _.templateSettings = { + evaluate : /<%([\s\S]+?)%>/g, + interpolate : /<%=([\s\S]+?)%>/g, + escape : /<%-([\s\S]+?)%>/g + }; + + // When customizing `templateSettings`, if you don't want to define an + // interpolation, evaluation or escaping regex, we need one that is + // guaranteed not to match. + var noMatch = /(.)^/; + + // Certain characters need to be escaped so that they can be put into a + // string literal. + var escapes = { + "'": "'", + '\\': '\\', + '\r': 'r', + '\n': 'n', + '\t': 't', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g; + + // JavaScript micro-templating, similar to John Resig's implementation. + // Underscore templating handles arbitrary delimiters, preserves whitespace, + // and correctly escapes quotes within interpolated code. + _.template = function(text, data, settings) { + var render; + settings = _.defaults({}, settings, _.templateSettings); + + // Combine delimiters into one regular expression via alternation. + var matcher = new RegExp([ + (settings.escape || noMatch).source, + (settings.interpolate || noMatch).source, + (settings.evaluate || noMatch).source + ].join('|') + '|$', 'g'); + + // Compile the template source, escaping string literals appropriately. + var index = 0; + var source = "__p+='"; + text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { + source += text.slice(index, offset) + .replace(escaper, function(match) { return '\\' + escapes[match]; }); + + if (escape) { + source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; + } + if (interpolate) { + source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; + } + if (evaluate) { + source += "';\n" + evaluate + "\n__p+='"; + } + index = offset + match.length; + return match; + }); + source += "';\n"; + + // If a variable is not specified, place data values in local scope. + if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n'; + + source = "var __t,__p='',__j=Array.prototype.join," + + "print=function(){__p+=__j.call(arguments,'');};\n" + + source + "return __p;\n"; + + try { + render = new Function(settings.variable || 'obj', '_', source); + } catch (e) { + e.source = source; + throw e; + } + + if (data) return render(data, _); + var template = function(data) { + return render.call(this, data, _); + }; + + // Provide the compiled function source as a convenience for precompilation. + template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}'; + + return template; + }; + + // Add a "chain" function, which will delegate to the wrapper. + _.chain = function(obj) { + return _(obj).chain(); + }; + + // OOP + // --------------- + // If Underscore is called as a function, it returns a wrapped object that + // can be used OO-style. This wrapper holds altered versions of all the + // underscore functions. Wrapped objects may be chained. + + // Helper function to continue chaining intermediate results. + var result = function(obj) { + return this._chain ? _(obj).chain() : obj; + }; + + // Add all of the Underscore functions to the wrapper object. + _.mixin(_); + + // Add all mutator Array functions to the wrapper. + each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + var obj = this._wrapped; + method.apply(obj, arguments); + if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0]; + return result.call(this, obj); + }; + }); + + // Add all accessor Array functions to the wrapper. + each(['concat', 'join', 'slice'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + return result.call(this, method.apply(this._wrapped, arguments)); + }; + }); + + _.extend(_.prototype, { + + // Start chaining a wrapped Underscore object. + chain: function() { + this._chain = true; + return this; + }, + + // Extracts the result from a wrapped and chained object. + value: function() { + return this._wrapped; + } + + }); + +}).call(this); + +},{}],146:[function(require,module,exports){ "use strict" function unique_pred(list, compare) { @@ -47306,7 +57443,7 @@ function unique(list, compare, sorted) { module.exports = unique -},{}],132:[function(require,module,exports){ +},{}],147:[function(require,module,exports){ var mime = require('mime'); var fs = require('fs'); @@ -47316,7 +57453,7 @@ module.exports = function urifyNode (file) { return 'data:' + type + ';base64,' + data; }; -},{"fs":42,"mime":63}],133:[function(require,module,exports){ +},{"fs":47,"mime":76}],148:[function(require,module,exports){ (function (global){ /** @@ -47387,18 +57524,18 @@ function config (name) { } }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{}],134:[function(require,module,exports){ -arguments[4][38][0].apply(exports,arguments) -},{"dup":38}],135:[function(require,module,exports){ -arguments[4][39][0].apply(exports,arguments) -},{"./support/isBuffer":134,"_process":98,"dup":39,"inherits":57}],136:[function(require,module,exports){ +},{}],149:[function(require,module,exports){ +arguments[4][43][0].apply(exports,arguments) +},{"dup":43}],150:[function(require,module,exports){ +arguments[4][44][0].apply(exports,arguments) +},{"./support/isBuffer":149,"_process":117,"dup":44,"inherits":70}],151:[function(require,module,exports){ // add steps to the sequencer function AddStep(_sequencer, image, name, o) { return require('./InsertStep')(_sequencer,image,-1,name,o); } module.exports = AddStep; -},{"./InsertStep":140}],137:[function(require,module,exports){ +},{"./InsertStep":155}],152:[function(require,module,exports){ var fs = require('fs'); var getDirectories = function(rootDir, cb) { fs.readdir(rootDir, function(err, files) { @@ -47473,7 +57610,7 @@ module.exports = function ExportBin(dir = "./output/", ref, basic, filename) { } } -},{"data-uri-to-buffer":13,"fs":42}],138:[function(require,module,exports){ +},{"data-uri-to-buffer":20,"fs":47}],153:[function(require,module,exports){ function objTypeOf(object){ return Object.prototype.toString.call(object).split(" ")[1].slice(0,-1) } @@ -47639,7 +57776,7 @@ function formatInput(args,format,images) { } module.exports = formatInput; -},{}],139:[function(require,module,exports){ +},{}],154:[function(require,module,exports){ if (typeof window !== 'undefined') { isBrowser = true } else { var isBrowser = false } require('./util/getStep.js'); @@ -48106,7 +58243,7 @@ ImageSequencer = function ImageSequencer(options) { } module.exports = ImageSequencer; -},{"./AddStep":136,"./ExportBin":137,"./FormatInput":138,"./InsertStep":140,"./Modules":141,"./ReplaceImage":142,"./Run":143,"./SavedSequences.json":145,"./ui/LoadImage":218,"./ui/SetInputStep":219,"./ui/UserInterface":220,"./util/getStep.js":222,"fs":42}],140:[function(require,module,exports){ +},{"./AddStep":151,"./ExportBin":152,"./FormatInput":153,"./InsertStep":155,"./Modules":156,"./ReplaceImage":157,"./Run":158,"./SavedSequences.json":160,"./ui/LoadImage":236,"./ui/SetInputStep":237,"./ui/UserInterface":238,"./util/getStep.js":240,"fs":47}],155:[function(require,module,exports){ const getStepUtils = require('./util/getStep.js'); // insert one or more steps at a given index in the sequencer @@ -48166,7 +58303,7 @@ function InsertStep(ref, image, index, name, o) { } module.exports = InsertStep; -},{"./util/getStep.js":222}],141:[function(require,module,exports){ +},{"./util/getStep.js":240}],156:[function(require,module,exports){ /* * Core modules and their info files */ @@ -48193,8 +58330,9 @@ module.exports = { 'histogram': require('./modules/Histogram'), 'gamma-correction': require('./modules/GammaCorrection'), 'convolution': require('./modules/Convolution'), + 'resize': require('./modules/Resize') } -},{"./modules/Average":147,"./modules/Blend":150,"./modules/Blur":154,"./modules/Brightness":157,"./modules/Channel":160,"./modules/Colorbar":163,"./modules/Colormap":167,"./modules/Convolution":171,"./modules/Crop":176,"./modules/DecodeQr":179,"./modules/Dynamic":182,"./modules/EdgeDetect":186,"./modules/FisheyeGl":189,"./modules/GammaCorrection":192,"./modules/Gradient":195,"./modules/Histogram":198,"./modules/ImportImage":202,"./modules/Ndvi":209,"./modules/NdviColormap":205,"./modules/Overlay":212,"./modules/Saturation":215,"image-sequencer-invert":56}],142:[function(require,module,exports){ +},{"./modules/Average":162,"./modules/Blend":165,"./modules/Blur":169,"./modules/Brightness":172,"./modules/Channel":175,"./modules/Colorbar":178,"./modules/Colormap":182,"./modules/Convolution":186,"./modules/Crop":191,"./modules/DecodeQr":194,"./modules/Dynamic":197,"./modules/EdgeDetect":201,"./modules/FisheyeGl":204,"./modules/GammaCorrection":207,"./modules/Gradient":210,"./modules/Histogram":213,"./modules/ImportImage":217,"./modules/Ndvi":221,"./modules/NdviColormap":224,"./modules/Overlay":227,"./modules/Resize":230,"./modules/Saturation":233,"image-sequencer-invert":61}],157:[function(require,module,exports){ // Uses a given image as input and replaces it with the output. // Works only in the browser. function ReplaceImage(ref,selector,steps,options) { @@ -48255,7 +58393,7 @@ function ReplaceImage(ref,selector,steps,options) { module.exports = ReplaceImage; -},{}],143:[function(require,module,exports){ +},{}],158:[function(require,module,exports){ const getStepUtils = require('./util/getStep.js'); function Run(ref, json_q, callback, ind, progressObj) { @@ -48350,7 +58488,7 @@ function Run(ref, json_q, callback, ind, progressObj) { } module.exports = Run; -},{"./RunToolkit":144,"./util/getStep.js":222}],144:[function(require,module,exports){ +},{"./RunToolkit":159,"./util/getStep.js":240}],159:[function(require,module,exports){ const getPixels = require('get-pixels'); const pixelManipulation = require('./modules/_nomodule/PixelManipulation'); const lodash = require('lodash'); @@ -48365,9 +58503,9 @@ module.exports = function(input) { input.savePixels = savePixels; return input; } -},{"./modules/_nomodule/PixelManipulation":217,"data-uri-to-buffer":13,"get-pixels":23,"lodash":62,"save-pixels":111}],145:[function(require,module,exports){ +},{"./modules/_nomodule/PixelManipulation":235,"data-uri-to-buffer":20,"get-pixels":30,"lodash":75,"save-pixels":138}],160:[function(require,module,exports){ module.exports={"sample":[{"name":"invert","options":{}},{"name":"channel","options":{"channel":"red"}},{"name":"blur","options":{"blur":"5"}}]} -},{}],146:[function(require,module,exports){ +},{}],161:[function(require,module,exports){ /* * Average all pixel colors */ @@ -48445,12 +58583,12 @@ module.exports = function Average(options, UI){ } } -},{"../_nomodule/PixelManipulation.js":217}],147:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],162:[function(require,module,exports){ module.exports = [ require('./Module'), require('./info.json') ] -},{"./Module":146,"./info.json":148}],148:[function(require,module,exports){ +},{"./Module":161,"./info.json":163}],163:[function(require,module,exports){ module.exports={ "name": "Average", "description": "Average all pixel color", @@ -48458,78 +58596,87 @@ module.exports={ } } -},{}],149:[function(require,module,exports){ +},{}],164:[function(require,module,exports){ module.exports = function Dynamic(options, UI, util) { - options.func = options.func || "function(r1, g1, b1, a1, r2, g2, b2, a2) { return [ r1, g2, b2, a2 ] }"; + options.func = options.func || "function(r1, g1, b1, a1, r2, g2, b2, a2) { return [ r1, g2, b2, a2 ] }"; + options.offset = options.offset || -2; - var output; + var output; - // This function is called on every draw. - function draw(input, callback, progressObj) { + // This function is called on every draw. + function draw(input, callback, progressObj) { - progressObj.stop(true); - progressObj.overrideFlag = true; + progressObj.stop(true); + progressObj.overrideFlag = true; - var step = this; + var step = this; - // convert to runnable code: - if (typeof options.func === "string") eval('options.func = ' + options.func); + // convert to runnable code: + if (typeof options.func === "string") eval('options.func = ' + options.func); - var getPixels = require('get-pixels'); + var getPixels = require('get-pixels'); - // save first image's pixels - var priorStep = this.getStep(-2); + // convert offset as string to int + if(typeof options.offset === "string") options.offset = parseInt(options.offset); - getPixels(priorStep.output.src, function(err, pixels) { - options.firstImagePixels = pixels; + // save first image's pixels + var priorStep = this.getStep(options.offset); - function changePixel(r2, g2, b2, a2, x, y) { - // blend! - var p = options.firstImagePixels; - return options.func( - r2, g2, b2, a2, - p.get(x, y, 0), - p.get(x, y, 1), - p.get(x, y, 2), - p.get(x, y, 3) - ) - } + getPixels(priorStep.output.src, function(err, pixels) { + options.firstImagePixels = pixels; - function output(image, datauri, mimetype) { + function changePixel(r2, g2, b2, a2, x, y) { + // blend! + var p = options.firstImagePixels; + return options.func( + r2, g2, b2, a2, + p.get(x, y, 0), + p.get(x, y, 1), + p.get(x, y, 2), + p.get(x, y, 3) + ) + } - // This output is accessible by Image Sequencer - step.output = { src: datauri, format: mimetype }; + function output(image, datauri, mimetype) { - } + // This output is accessible by Image Sequencer + step.output = { src: datauri, format: mimetype }; - // run PixelManipulatin on second image's pixels - return require('../_nomodule/PixelManipulation.js')(input, { + } + + // run PixelManipulatin on second image's pixels + return require('../_nomodule/PixelManipulation.js')(input, { + output: output, + changePixel: changePixel, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + callback: callback + }); + }); + } + + return { + options: options, + draw: draw, output: output, - changePixel: changePixel, - format: input.format, - image: options.image, - inBrowser: options.inBrowser, - callback: callback - }); - }); - } - - return { - options: options, - draw: draw, - output: output, - UI: UI - } + UI: UI + } } -},{"../_nomodule/PixelManipulation.js":217,"get-pixels":23}],150:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":149,"./info.json":151,"dup":147}],151:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"get-pixels":30}],165:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":164,"./info.json":166,"dup":162}],166:[function(require,module,exports){ module.exports={ "name": "Blend", - "description": "Blend the past two image steps with the given function. Defaults to using the red channel from image 1 and the green and blue and alpha channels of image 2. Easier to use interfaces coming soon!", + "description": "Blend two chosen image steps with the given function. Defaults to using the red channel from image 1 and the green and blue and alpha channels of image 2. Easier to use interfaces coming soon!", "inputs": { + "offset": { + "type": "integer", + "desc": "Choose which image to blend the current image with. Two steps back is -2, three steps back is -3 etc.", + "default": -2 + }, "blend": { "type": "input", "desc": "Function to use to blend the two images.", @@ -48538,7 +58685,7 @@ module.exports={ } } -},{}],152:[function(require,module,exports){ +},{}],167:[function(require,module,exports){ module.exports = exports = function(pixels, blur) { let kernel = kernelGenerator(blur, 1), oldpix = pixels; kernel = flipKernel(kernel); @@ -48623,7 +58770,7 @@ module.exports = exports = function(pixels, blur) { return result; } } -},{}],153:[function(require,module,exports){ +},{}],168:[function(require,module,exports){ /* * Blur an Image */ @@ -48673,9 +58820,9 @@ module.exports = function Blur(options, UI) { } } -},{"../_nomodule/PixelManipulation.js":217,"./Blur":152}],154:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":153,"./info.json":155,"dup":147}],155:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"./Blur":167}],169:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":168,"./info.json":170,"dup":162}],170:[function(require,module,exports){ module.exports={ "name": "Blur", "description": "Applies a Gaussian blur given by the intensity value", @@ -48691,7 +58838,7 @@ module.exports={ } } -},{}],156:[function(require,module,exports){ +},{}],171:[function(require,module,exports){ /* * Changes the Image Brightness */ @@ -48747,9 +58894,9 @@ module.exports = function Brightness(options,UI){ } } -},{"../_nomodule/PixelManipulation.js":217}],157:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":156,"./info.json":158,"dup":147}],158:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],172:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":171,"./info.json":173,"dup":162}],173:[function(require,module,exports){ module.exports={ "name": "Brightness", "description": "Change the brightness of the image by given percent value", @@ -48765,7 +58912,7 @@ module.exports={ } } -},{}],159:[function(require,module,exports){ +},{}],174:[function(require,module,exports){ /* * Display only one color channel */ @@ -48815,9 +58962,9 @@ module.exports = function Channel(options, UI) { } } -},{"../_nomodule/PixelManipulation.js":217}],160:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":159,"./info.json":161,"dup":147}],161:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],175:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":174,"./info.json":176,"dup":162}],176:[function(require,module,exports){ module.exports={ "name": "Channel", "description": "Displays only one color channel of an image -- default is green", @@ -48831,7 +58978,7 @@ module.exports={ } } -},{}],162:[function(require,module,exports){ +},{}],177:[function(require,module,exports){ module.exports = function NdviColormapfunction(options, UI) { options.x = options.x || 0; @@ -48848,9 +58995,9 @@ module.exports = function NdviColormapfunction(options, UI) { isMeta: true } } -},{}],163:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":162,"./info.json":164,"dup":147}],164:[function(require,module,exports){ +},{}],178:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":177,"./info.json":179,"dup":162}],179:[function(require,module,exports){ module.exports={ "name": "Colorbar", "description": "Generates a colorbar to lay over the image", @@ -48884,7 +59031,7 @@ module.exports={ }, "length": 4 } -},{}],165:[function(require,module,exports){ +},{}],180:[function(require,module,exports){ /* * Accepts a value from 0-255 and returns the new color-mapped pixel * from a lookup table, which can be specified as an array of [begin, end] @@ -48973,7 +59120,7 @@ var colormaps = { ]) } -},{}],166:[function(require,module,exports){ +},{}],181:[function(require,module,exports){ module.exports = function Colormap(options,UI) { var output; @@ -49017,9 +59164,9 @@ module.exports = function Colormap(options,UI) { } } -},{"../_nomodule/PixelManipulation.js":217,"./Colormap":165}],167:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":166,"./info.json":168,"dup":147}],168:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"./Colormap":180}],182:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":181,"./info.json":183,"dup":162}],183:[function(require,module,exports){ module.exports={ "name": "Colormap", "description": "Maps brightness values (average of red, green & blue) to a given color lookup table, made up of a set of one more color gradients.\n\nFor example, 'cooler' colors like blue could represent low values, while 'hot' colors like red could represent high values.", @@ -49033,7 +59180,7 @@ module.exports={ } } -},{}],169:[function(require,module,exports){ +},{}],184:[function(require,module,exports){ var _ = require('lodash'); module.exports = exports = function(pixels, constantFactor, kernelValues){ let kernel = kernelGenerator(constantFactor, kernelValues), oldpix = _.cloneDeep(pixels); @@ -49105,7 +59252,7 @@ module.exports = exports = function(pixels, constantFactor, kernelValues){ return result; } } -},{"lodash":62}],170:[function(require,module,exports){ +},{"lodash":75}],185:[function(require,module,exports){ module.exports = function Convolution(options, UI) { options.kernelValues = options.kernelValues || '1 1 1 1 1 1 1 1 1'; @@ -49152,9 +59299,9 @@ module.exports = function Convolution(options, UI) { } } -},{"../_nomodule/PixelManipulation.js":217,"./Convolution":169}],171:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":170,"./info.json":172,"dup":147}],172:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"./Convolution":184}],186:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":185,"./info.json":187,"dup":162}],187:[function(require,module,exports){ module.exports={ "name": "Convolution", "description": "Image Convolution using a given 3x3 kernel matrix Read more", @@ -49175,7 +59322,7 @@ module.exports={ } } -},{}],173:[function(require,module,exports){ +},{}],188:[function(require,module,exports){ (function (Buffer){ module.exports = function Crop(input,options,callback) { @@ -49221,7 +59368,7 @@ module.exports = function Crop(input,options,callback) { }; }).call(this,require("buffer").Buffer) -},{"buffer":4,"get-pixels":23,"save-pixels":111}],174:[function(require,module,exports){ +},{"buffer":5,"get-pixels":30,"save-pixels":138}],189:[function(require,module,exports){ /* * Image Cropping module * Usage: @@ -49293,7 +59440,7 @@ module.exports = function CropModule(options, UI) { } } -},{"./Crop":173,"./Ui.js":175}],175:[function(require,module,exports){ +},{"./Crop":188,"./Ui.js":190}],190:[function(require,module,exports){ // hide on save module.exports = function CropModuleUi(step, ui) { @@ -49392,9 +59539,9 @@ module.exports = function CropModuleUi(step, ui) { } } -},{}],176:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":174,"./info.json":177,"dup":147}],177:[function(require,module,exports){ +},{}],191:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":189,"./info.json":192,"dup":162}],192:[function(require,module,exports){ module.exports={ "name": "Crop", "description": "Crop image to given x, y, w, h in pixels, measured from top left", @@ -49422,7 +59569,7 @@ module.exports={ } } } -},{}],178:[function(require,module,exports){ +},{}],193:[function(require,module,exports){ /* * Decodes QR from a given image. */ @@ -49465,9 +59612,9 @@ module.exports = function DoNothing(options,UI) { } } -},{"get-pixels":23,"jsqr":61}],179:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":178,"./info.json":180,"dup":147}],180:[function(require,module,exports){ +},{"get-pixels":30,"jsqr":74}],194:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":193,"./info.json":195,"dup":162}],195:[function(require,module,exports){ module.exports={ "name": "Decode QR", "description": "Search for and decode a QR code in the image", @@ -49480,7 +59627,7 @@ module.exports={ } } -},{}],181:[function(require,module,exports){ +},{}],196:[function(require,module,exports){ module.exports = function Dynamic(options,UI) { var output; @@ -49537,6 +59684,22 @@ module.exports = function Dynamic(options,UI) { ] } + // via P5js: https://github.com/processing/p5.js/blob/2920492842aae9a8bf1a779916893ac19d65cd38/src/math/calculation.js#L461-L472 + function map(n, start1, stop1, start2, stop2, withinBounds) { + var newval = (n - start1) / (stop1 - start1) * (stop2 - start2) + start2; + if (!withinBounds) { + return newval; + } + // also via P5js: https://github.com/processing/p5.js/blob/2920492842aae9a8bf1a779916893ac19d65cd38/src/math/calculation.js#L116-L119 + function constrain(n, low, high) { + return Math.max(Math.min(n, high), low); + }; + if (start2 < stop2) { + return constrain(newval, start2, stop2); + } else { + return constrain(newval, stop2, start2); + } + }; function output(image,datauri,mimetype){ @@ -49565,9 +59728,9 @@ module.exports = function Dynamic(options,UI) { } } -},{"../_nomodule/PixelManipulation.js":217}],182:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":181,"./info.json":183,"dup":147}],183:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],197:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":196,"./info.json":198,"dup":162}],198:[function(require,module,exports){ module.exports={ "name": "Dynamic", "description": "A module which accepts JavaScript math expressions to produce each color channel based on the original image's color. See Infragrammar.", @@ -49595,7 +59758,7 @@ module.exports={ } } -},{}],184:[function(require,module,exports){ +},{}],199:[function(require,module,exports){ const _ = require('lodash') //define kernels for the sobel filter @@ -49771,7 +59934,7 @@ function doubleThreshold(pixels, highThresholdRatio, lowThresholdRatio, mags, st -},{"lodash":62}],185:[function(require,module,exports){ +},{"lodash":75}],200:[function(require,module,exports){ /* * Detect Edges in an Image */ @@ -49830,12 +59993,12 @@ module.exports = function edgeDetect(options, UI) { } } -},{"../_nomodule/PixelManipulation.js":217,"./EdgeUtils":184,"ndarray-gaussian-filter":67}],186:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":185,"./info.json":187,"dup":147}],187:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"./EdgeUtils":199,"ndarray-gaussian-filter":80}],201:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":200,"./info.json":202,"dup":162}],202:[function(require,module,exports){ module.exports={ "name": "Detect Edges", - "description": "this module detects edges using the Canny method, which first Gaussian blurs the image to reduce noise (amount of blur configurable in settings as `options.blur`), then applies a number of steps to highlight edges, resulting in a greyscale image where the brighter the pixel, the stronger the detected edge. Read more at: https://en.wikipedia.org/wiki/Canny_edge_detector", + "description": "this module detects edges using the Canny method, which first Gaussian blurs the image to reduce noise (amount of blur configurable in settings as `options.blur`), then applies a number of steps to highlight edges, resulting in a greyscale image where the brighter the pixel, the stronger the detected edge. Read more. ", "inputs": { "blur": { "type": "integer", @@ -49855,7 +60018,7 @@ module.exports={ } } -},{}],188:[function(require,module,exports){ +},{}],203:[function(require,module,exports){ /* * Resolves Fisheye Effect */ @@ -49927,9 +60090,9 @@ module.exports = function DoNothing(options,UI) { } } -},{"fisheyegl":15}],189:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":188,"./info.json":190,"dup":147}],190:[function(require,module,exports){ +},{"fisheyegl":22}],204:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":203,"./info.json":205,"dup":162}],205:[function(require,module,exports){ module.exports={ "name": "Fisheye GL", "description": "Correct fisheye, or barrel distortion, in images (with WebGL -- adapted from fisheye-correction-webgl by @bluemir).", @@ -49997,7 +60160,7 @@ module.exports={ } } -},{}],191:[function(require,module,exports){ +},{}],206:[function(require,module,exports){ module.exports = function Gamma(options,UI){ var output; @@ -50043,9 +60206,9 @@ module.exports = function Gamma(options,UI){ } } -},{"../_nomodule/PixelManipulation.js":217}],192:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":191,"./info.json":193,"dup":147}],193:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],207:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":206,"./info.json":208,"dup":162}],208:[function(require,module,exports){ module.exports={ "name": "Gamma Correction", "description": "Apply gamma correction on the image Read more", @@ -50058,7 +60221,7 @@ module.exports={ } } -},{}],194:[function(require,module,exports){ +},{}],209:[function(require,module,exports){ (function (Buffer){ module.exports = function Invert(options, UI) { @@ -50124,15 +60287,15 @@ module.exports = function Invert(options, UI) { } }).call(this,require("buffer").Buffer) -},{"buffer":4,"get-pixels":23,"save-pixels":111}],195:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":194,"./info.json":196,"dup":147}],196:[function(require,module,exports){ +},{"buffer":5,"get-pixels":30,"save-pixels":138}],210:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":209,"./info.json":211,"dup":162}],211:[function(require,module,exports){ module.exports={ "name": "Gradient", "description": "Gives a gradient of the image", "inputs": {} } -},{}],197:[function(require,module,exports){ +},{}],212:[function(require,module,exports){ /* * Calculates the histogram of the image */ @@ -50227,12 +60390,12 @@ module.exports = function Channel(options, UI) { } } -},{"../_nomodule/PixelManipulation.js":217}],198:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],213:[function(require,module,exports){ module.exports = [ require('./Module.js'), require('./info.json') ] -},{"./Module.js":197,"./info.json":199}],199:[function(require,module,exports){ +},{"./Module.js":212,"./info.json":214}],214:[function(require,module,exports){ module.exports={ "name": "Histogram", "description": "Calculates the histogram for the image", @@ -50248,7 +60411,7 @@ module.exports={ } } } -},{}],200:[function(require,module,exports){ +},{}],215:[function(require,module,exports){ /* * Import Image module; this fetches a given remote or local image via URL * or data-url, and overwrites the current one. It saves the original as @@ -50308,7 +60471,7 @@ module.exports = function ImportImageModule(options, UI) { } } -},{"../../util/GetFormat":221,"./Ui.js":201}],201:[function(require,module,exports){ +},{"../../util/GetFormat":239,"./Ui.js":216}],216:[function(require,module,exports){ // hide on save module.exports = function ImportImageModuleUi(step, ui) { @@ -50364,9 +60527,9 @@ module.exports = function ImportImageModuleUi(step, ui) { } } -},{}],202:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":200,"./info.json":203,"dup":147}],203:[function(require,module,exports){ +},{}],217:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":215,"./info.json":218,"dup":162}],218:[function(require,module,exports){ module.exports={ "name": "Import Image", "description": "Import a new image and replace the original with it. Future versions may enable a blend mode. Specify an image by URL or by file selector.", @@ -50379,26 +60542,7 @@ module.exports={ } } } -},{}],204:[function(require,module,exports){ -/* - * Sample Meta Module for demonstration purpose only - */ -module.exports = function NdviColormapfunction() { - this.expandSteps([{ 'name': 'ndvi', 'options': {} }, { 'name': 'colormap', options: {} }]); - return { - isMeta: true - } -} -},{}],205:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":204,"./info.json":206,"dup":147}],206:[function(require,module,exports){ -module.exports={ - "name": "NDVI-Colormap", - "description": "Sequentially Applies NDVI and Colormap steps", - "inputs": {}, - "length": 2 -} -},{}],207:[function(require,module,exports){ +},{}],219:[function(require,module,exports){ /* * NDVI with red filter (blue channel is infrared) */ @@ -50458,7 +60602,7 @@ module.exports = function Ndvi(options, UI) { } } -},{"../_nomodule/PixelManipulation.js":217,"./Ui.js":208}],208:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"./Ui.js":220}],220:[function(require,module,exports){ // hide on save module.exports = function CropModuleUi(step, ui) { @@ -50494,9 +60638,9 @@ module.exports = function CropModuleUi(step, ui) { } } -},{}],209:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":207,"./info.json":210,"dup":147}],210:[function(require,module,exports){ +},{}],221:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":219,"./info.json":222,"dup":162}],222:[function(require,module,exports){ module.exports={ "name": "NDVI", "description": "Normalized Difference Vegetation Index, or NDVI, is an image analysis technique used with aerial photography. It's a way to visualize the amounts of infrared and other wavelengths of light reflected from vegetation by comparing ratios of blue and red light absorbed versus green and IR light reflected. NDVI is used to evaluate the health of vegetation in satellite imagery, where it correlates with how much photosynthesis is happening. This is helpful in assessing vegetative health or stress. Read more.

This is designed for use with red-filtered single camera DIY Infragram cameras; change to 'blue' for blue filters", @@ -50510,7 +60654,26 @@ module.exports={ } } -},{}],211:[function(require,module,exports){ +},{}],223:[function(require,module,exports){ +/* + * Sample Meta Module for demonstration purpose only + */ +module.exports = function NdviColormapfunction() { + this.expandSteps([{ 'name': 'ndvi', 'options': {} }, { 'name': 'colormap', options: {} }]); + return { + isMeta: true + } +} +},{}],224:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":223,"./info.json":225,"dup":162}],225:[function(require,module,exports){ +module.exports={ + "name": "NDVI-Colormap", + "description": "Sequentially Applies NDVI and Colormap steps", + "inputs": {}, + "length": 2 +} +},{}],226:[function(require,module,exports){ module.exports = function Dynamic(options, UI, util) { options.x = options.x || 0; @@ -50582,9 +60745,9 @@ module.exports = function Dynamic(options, UI, util) { } } -},{"../_nomodule/PixelManipulation.js":217,"get-pixels":23}],212:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":211,"./info.json":213,"dup":147}],213:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235,"get-pixels":30}],227:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":226,"./info.json":228,"dup":162}],228:[function(require,module,exports){ module.exports={ "name": "Overlay", "description": "Overlays an Image over another at a given position(x,y)", @@ -50606,7 +60769,94 @@ module.exports={ } } } -},{}],214:[function(require,module,exports){ +},{}],229:[function(require,module,exports){ +/* + * Resize the image by given percentage value + */ +module.exports = function Resize(options, UI) { + + var output; + + function draw(input, callback, progressObj) { + + options.resize = options.resize || "125%"; + + progressObj.stop(true); + progressObj.overrideFlag = true; + + var step = this; + + var imagejs = require('imagejs'); + + function changePixel(r, g, b, a) { + return [r, g, b, a] + } + + function extraManipulation(pixels) { + // value above 100% scales up, and below 100% scales down + var resize_value = parseInt(options.resize.slice(0, -1)); + + var new_width, + new_height; + + new_width = Math.round(pixels.shape[0] * (resize_value / 100)); + new_height = Math.round(pixels.shape[1] * (resize_value / 100)); + + var bitmap = new imagejs.Bitmap({width: pixels.shape[0], height: pixels.shape[1]}); + bitmap._data.data = pixels.data; + + + var resized = bitmap.resize({ + width: new_width, height: new_height, + algorithm: "bicubicInterpolation" + }); + + pixels.data = resized._data.data; + pixels.shape = [new_width,new_height,4]; + pixels.stride[1] = 4 * new_width; + + return pixels; + } + + function output(image, datauri, mimetype) { + // This output is accesible by Image Sequencer + step.output = { src: datauri, format: mimetype }; + } + + return require('../_nomodule/PixelManipulation.js')(input, { + output: output, + changePixel: changePixel, + extraManipulation: extraManipulation, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + callback: callback + }); + } + + return { + options: options, + draw: draw, + output: output, + UI: UI + } +} + +},{"../_nomodule/PixelManipulation.js":235,"imagejs":62}],230:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":229,"./info.json":231,"dup":162}],231:[function(require,module,exports){ +module.exports={ + "name": "Resize", + "description": "Resize image by given percentage value", + "inputs": { + "resize": { + "type": "string", + "desc": "Percentage value of the resize", + "default": "125%" + } + } +} +},{}],232:[function(require,module,exports){ /* * Saturate an image with a value from 0 to 1 */ @@ -50664,9 +60914,9 @@ module.exports = function Saturation(options,UI) { } } -},{"../_nomodule/PixelManipulation.js":217}],215:[function(require,module,exports){ -arguments[4][147][0].apply(exports,arguments) -},{"./Module":214,"./info.json":216,"dup":147}],216:[function(require,module,exports){ +},{"../_nomodule/PixelManipulation.js":235}],233:[function(require,module,exports){ +arguments[4][162][0].apply(exports,arguments) +},{"./Module":232,"./info.json":234,"dup":162}],234:[function(require,module,exports){ module.exports={ "name": "Saturation", "description": "Change the saturation of the image by given value, from 0-1, with 1 being 100% saturated.", @@ -50679,7 +60929,7 @@ module.exports={ } } -},{}],217:[function(require,module,exports){ +},{}],235:[function(require,module,exports){ (function (process,Buffer){ /* * General purpose per-pixel manipulation @@ -50780,7 +61030,7 @@ module.exports = function PixelManipulation(image, options) { }; }).call(this,require('_process'),require("buffer").Buffer) -},{"_process":98,"buffer":4,"get-pixels":23,"pace":74,"save-pixels":111}],218:[function(require,module,exports){ +},{"_process":117,"buffer":5,"get-pixels":30,"pace":94,"save-pixels":138}],236:[function(require,module,exports){ // special module to load an image into the start of the sequence; used in the HTML UI function LoadImage(ref, name, src, main_callback) { function makeImage(datauri) { @@ -50887,7 +61137,7 @@ function LoadImage(ref, name, src, main_callback) { module.exports = LoadImage; -},{"urify":132}],219:[function(require,module,exports){ +},{"urify":147}],237:[function(require,module,exports){ // TODO: potentially move this into ImportImage module function setInputStepInit() { @@ -50939,7 +61189,7 @@ function setInputStepInit() { } module.exports = setInputStepInit; -},{}],220:[function(require,module,exports){ +},{}],238:[function(require,module,exports){ /* * User Interface Handling Module */ @@ -50999,7 +61249,7 @@ module.exports = function UserInterface(events = {}) { } -},{}],221:[function(require,module,exports){ +},{}],239:[function(require,module,exports){ /* * Determine format from a URL or data-url, return "jpg" "png" "gif" etc * TODO: write a test for this using the examples @@ -51041,7 +61291,7 @@ module.exports = function GetFormat(src) { } -},{}],222:[function(require,module,exports){ +},{}],240:[function(require,module,exports){ module.exports = { getPreviousStep: function() { return this.getStep(-1); @@ -51091,4 +61341,4 @@ module.exports = { img.src = this.getInput(0).src; } } -},{}]},{},[139]); +},{}]},{},[154]); diff --git a/dist/image-sequencer.min.js b/dist/image-sequencer.min.js index fcfd3d12..d1b52002 100644 --- a/dist/image-sequencer.min.js +++ b/dist/image-sequencer.min.js @@ -1 +1 @@ -!function(){return function e(t,n,r){function i(o,s){if(!n[o]){if(!t[o]){var u="function"==typeof require&&require;if(!s&&u)return u(o,!0);if(a)return a(o,!0);var l=new Error("Cannot find module '"+o+"'");throw l.code="MODULE_NOT_FOUND",l}var c=n[o]={exports:{}};t[o][0].call(c.exports,function(e){return i(t[o][1][e]||e)},c,c.exports,e,t,n,r)}return n[o].exports}for(var a="function"==typeof require&&require,o=0;o0?r-4:r,f=0;f>16&255,s[u++]=t>>8&255,s[u++]=255&t;2===o&&(t=i[e.charCodeAt(f)]<<2|i[e.charCodeAt(f+1)]>>4,s[u++]=255&t);1===o&&(t=i[e.charCodeAt(f)]<<10|i[e.charCodeAt(f+1)]<<4|i[e.charCodeAt(f+2)]>>2,s[u++]=t>>8&255,s[u++]=255&t);return s},n.fromByteArray=function(e){for(var t,n=e.length,i=n%3,a=[],o=0,s=n-i;os?s:o+16383));1===i?(t=e[n-1],a.push(r[t>>2]+r[t<<4&63]+"==")):2===i&&(t=(e[n-2]<<8)+e[n-1],a.push(r[t>>10]+r[t>>4&63]+r[t<<2&63]+"="));return a.join("")};for(var r=[],i=[],a="undefined"!=typeof Uint8Array?Uint8Array:Array,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=0,u=o.length;s0)throw new Error("Invalid string. Length must be a multiple of 4");var n=e.indexOf("=");return-1===n&&(n=t),[n,n===t?0:4-n%4]}function c(e,t,n){for(var i,a,o=[],s=t;s>18&63]+r[a>>12&63]+r[a>>6&63]+r[63&a]);return o.join("")}i["-".charCodeAt(0)]=62,i["_".charCodeAt(0)]=63},{}],2:[function(e,t,n){"use strict";"use restrict";function r(e){var t=32;return(e&=-e)&&t--,65535&e&&(t-=16),16711935&e&&(t-=8),252645135&e&&(t-=4),858993459&e&&(t-=2),1431655765&e&&(t-=1),t}n.INT_BITS=32,n.INT_MAX=2147483647,n.INT_MIN=-1<<31,n.sign=function(e){return(e>0)-(e<0)},n.abs=function(e){var t=e>>31;return(e^t)-t},n.min=function(e,t){return t^(e^t)&-(e65535)<<4,t|=n=((e>>>=t)>255)<<3,t|=n=((e>>>=n)>15)<<2,(t|=n=((e>>>=n)>3)<<1)|(e>>>=n)>>1},n.log10=function(e){return e>=1e9?9:e>=1e8?8:e>=1e7?7:e>=1e6?6:e>=1e5?5:e>=1e4?4:e>=1e3?3:e>=100?2:e>=10?1:0},n.popCount=function(e){return 16843009*((e=(858993459&(e-=e>>>1&1431655765))+(e>>>2&858993459))+(e>>>4)&252645135)>>>24},n.countTrailingZeros=r,n.nextPow2=function(e){return e+=0===e,--e,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,(e|=e>>>16)+1},n.prevPow2=function(e){return e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,(e|=e>>>16)-(e>>>1)},n.parity=function(e){return e^=e>>>16,e^=e>>>8,e^=e>>>4,27030>>>(e&=15)&1};var i=new Array(256);!function(e){for(var t=0;t<256;++t){var n=t,r=t,i=7;for(n>>>=1;n;n>>>=1)r<<=1,r|=1&n,--i;e[t]=r<>>8&255]<<16|i[e>>>16&255]<<8|i[e>>>24&255]},n.interleave2=function(e,t){return(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e&=65535)|e<<8))|e<<4))|e<<2))|e<<1))|(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t&=65535)|t<<8))|t<<4))|t<<2))|t<<1))<<1},n.deinterleave2=function(e,t){return(e=65535&((e=16711935&((e=252645135&((e=858993459&((e=e>>>t&1431655765)|e>>>1))|e>>>2))|e>>>4))|e>>>16))<<16>>16},n.interleave3=function(e,t,n){return e=1227133513&((e=3272356035&((e=251719695&((e=4278190335&((e&=1023)|e<<16))|e<<8))|e<<4))|e<<2),(e|=(t=1227133513&((t=3272356035&((t=251719695&((t=4278190335&((t&=1023)|t<<16))|t<<8))|t<<4))|t<<2))<<1)|(n=1227133513&((n=3272356035&((n=251719695&((n=4278190335&((n&=1023)|n<<16))|n<<8))|n<<4))|n<<2))<<2},n.deinterleave3=function(e,t){return(e=1023&((e=4278190335&((e=251719695&((e=3272356035&((e=e>>>t&1227133513)|e>>>2))|e>>>4))|e>>>8))|e>>>16))<<22>>22},n.nextCombination=function(e){var t=e|e-1;return t+1|(~t&-~t)-1>>>r(e)+1}},{}],3:[function(e,t,n){},{}],4:[function(e,t,n){"use strict";var r=e("base64-js"),i=e("ieee754");n.Buffer=s,n.SlowBuffer=function(e){+e!=e&&(e=0);return s.alloc(+e)},n.INSPECT_MAX_BYTES=50;var a=2147483647;function o(e){if(e>a)throw new RangeError("Invalid typed array length");var t=new Uint8Array(e);return t.__proto__=s.prototype,t}function s(e,t,n){if("number"==typeof e){if("string"==typeof t)throw new Error("If encoding is specified then the first argument must be a string");return c(e)}return u(e,t,n)}function u(e,t,n){if("number"==typeof e)throw new TypeError('"value" argument must not be a number');return P(e)?function(e,t,n){if(t<0||e.byteLength=a)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a.toString(16)+" bytes");return 0|e}function p(e,t){if(s.isBuffer(e))return e.length;if(U(e)||P(e))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return D(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return F(e).length;default:if(r)return D(e).length;t=(""+t).toLowerCase(),r=!0}}function d(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function g(e,t,n,r,i){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):n>2147483647?n=2147483647:n<-2147483648&&(n=-2147483648),q(n=+n)&&(n=i?0:e.length-1),n<0&&(n=e.length+n),n>=e.length){if(i)return-1;n=e.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof t&&(t=s.from(t,r)),s.isBuffer(t))return 0===t.length?-1:v(e,t,n,r,i);if("number"==typeof t)return t&=255,"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):v(e,[t],n,r,i);throw new TypeError("val must be string, number or Buffer")}function v(e,t,n,r,i){var a,o=1,s=e.length,u=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;o=2,s/=2,u/=2,n/=2}function l(e,t){return 1===o?e[t]:e.readUInt16BE(t*o)}if(i){var c=-1;for(a=n;as&&(n=s-u),a=n;a>=0;a--){for(var f=!0,h=0;hi&&(r=i):r=i;var a=t.length;if(a%2!=0)throw new TypeError("Invalid hex string");r>a/2&&(r=a/2);for(var o=0;o>8,i=n%256,a.push(i),a.push(r);return a}(t,e.length-n),e,n,r)}function k(e,t,n){return 0===t&&n===e.length?r.fromByteArray(e):r.fromByteArray(e.slice(t,n))}function E(e,t,n){n=Math.min(e.length,n);for(var r=[],i=t;i239?4:l>223?3:l>191?2:1;if(i+f<=n)switch(f){case 1:l<128&&(c=l);break;case 2:128==(192&(a=e[i+1]))&&(u=(31&l)<<6|63&a)>127&&(c=u);break;case 3:a=e[i+1],o=e[i+2],128==(192&a)&&128==(192&o)&&(u=(15&l)<<12|(63&a)<<6|63&o)>2047&&(u<55296||u>57343)&&(c=u);break;case 4:a=e[i+1],o=e[i+2],s=e[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&(u=(15&l)<<18|(63&a)<<12|(63&o)<<6|63&s)>65535&&u<1114112&&(c=u)}null===c?(c=65533,f=1):c>65535&&(c-=65536,r.push(c>>>10&1023|55296),c=56320|1023&c),r.push(c),i+=f}return function(e){var t=e.length;if(t<=S)return String.fromCharCode.apply(String,e);var n="",r=0;for(;rthis.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return T(this,t,n);case"utf8":case"utf-8":return E(this,t,n);case"ascii":return A(this,t,n);case"latin1":case"binary":return M(this,t,n);case"base64":return k(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return j(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}.apply(this,arguments)},s.prototype.equals=function(e){if(!s.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===s.compare(this,e)},s.prototype.inspect=function(){var e="",t=n.INSPECT_MAX_BYTES;return this.length>0&&(e=this.toString("hex",0,t).match(/.{2}/g).join(" "),this.length>t&&(e+=" ... ")),""},s.prototype.compare=function(e,t,n,r,i){if(!s.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),t<0||n>e.length||r<0||i>this.length)throw new RangeError("out of range index");if(r>=i&&t>=n)return 0;if(r>=i)return-1;if(t>=n)return 1;if(t>>>=0,n>>>=0,r>>>=0,i>>>=0,this===e)return 0;for(var a=i-r,o=n-t,u=Math.min(a,o),l=this.slice(r,i),c=e.slice(t,n),f=0;f>>=0,isFinite(n)?(n>>>=0,void 0===r&&(r="utf8")):(r=n,n=void 0)}var i=this.length-t;if((void 0===n||n>i)&&(n=i),e.length>0&&(n<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var a=!1;;)switch(r){case"hex":return m(this,e,t,n);case"utf8":case"utf-8":return _(this,e,t,n);case"ascii":return w(this,e,t,n);case"latin1":case"binary":return b(this,e,t,n);case"base64":return y(this,e,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return x(this,e,t,n);default:if(a)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),a=!0}},s.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var S=4096;function A(e,t,n){var r="";n=Math.min(e.length,n);for(var i=t;ir)&&(n=r);for(var i="",a=t;an)throw new RangeError("Trying to access beyond buffer length")}function R(e,t,n,r,i,a){if(!s.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||te.length)throw new RangeError("Index out of range")}function C(e,t,n,r,i,a){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function B(e,t,n,r,a){return t=+t,n>>>=0,a||C(e,0,n,4),i.write(e,t,n,r,23,4),n+4}function L(e,t,n,r,a){return t=+t,n>>>=0,a||C(e,0,n,8),i.write(e,t,n,r,52,8),n+8}s.prototype.slice=function(e,t){var n=this.length;e=~~e,t=void 0===t?n:~~t,e<0?(e+=n)<0&&(e=0):e>n&&(e=n),t<0?(t+=n)<0&&(t=0):t>n&&(t=n),t>>=0,t>>>=0,n||I(e,t,this.length);for(var r=this[e],i=1,a=0;++a>>=0,t>>>=0,n||I(e,t,this.length);for(var r=this[e+--t],i=1;t>0&&(i*=256);)r+=this[e+--t]*i;return r},s.prototype.readUInt8=function(e,t){return e>>>=0,t||I(e,1,this.length),this[e]},s.prototype.readUInt16LE=function(e,t){return e>>>=0,t||I(e,2,this.length),this[e]|this[e+1]<<8},s.prototype.readUInt16BE=function(e,t){return e>>>=0,t||I(e,2,this.length),this[e]<<8|this[e+1]},s.prototype.readUInt32LE=function(e,t){return e>>>=0,t||I(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},s.prototype.readUInt32BE=function(e,t){return e>>>=0,t||I(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},s.prototype.readIntLE=function(e,t,n){e>>>=0,t>>>=0,n||I(e,t,this.length);for(var r=this[e],i=1,a=0;++a=(i*=128)&&(r-=Math.pow(2,8*t)),r},s.prototype.readIntBE=function(e,t,n){e>>>=0,t>>>=0,n||I(e,t,this.length);for(var r=t,i=1,a=this[e+--r];r>0&&(i*=256);)a+=this[e+--r]*i;return a>=(i*=128)&&(a-=Math.pow(2,8*t)),a},s.prototype.readInt8=function(e,t){return e>>>=0,t||I(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},s.prototype.readInt16LE=function(e,t){e>>>=0,t||I(e,2,this.length);var n=this[e]|this[e+1]<<8;return 32768&n?4294901760|n:n},s.prototype.readInt16BE=function(e,t){e>>>=0,t||I(e,2,this.length);var n=this[e+1]|this[e]<<8;return 32768&n?4294901760|n:n},s.prototype.readInt32LE=function(e,t){return e>>>=0,t||I(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},s.prototype.readInt32BE=function(e,t){return e>>>=0,t||I(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},s.prototype.readFloatLE=function(e,t){return e>>>=0,t||I(e,4,this.length),i.read(this,e,!0,23,4)},s.prototype.readFloatBE=function(e,t){return e>>>=0,t||I(e,4,this.length),i.read(this,e,!1,23,4)},s.prototype.readDoubleLE=function(e,t){return e>>>=0,t||I(e,8,this.length),i.read(this,e,!0,52,8)},s.prototype.readDoubleBE=function(e,t){return e>>>=0,t||I(e,8,this.length),i.read(this,e,!1,52,8)},s.prototype.writeUIntLE=function(e,t,n,r){(e=+e,t>>>=0,n>>>=0,r)||R(this,e,t,n,Math.pow(2,8*n)-1,0);var i=1,a=0;for(this[t]=255&e;++a>>=0,n>>>=0,r)||R(this,e,t,n,Math.pow(2,8*n)-1,0);var i=n-1,a=1;for(this[t+i]=255&e;--i>=0&&(a*=256);)this[t+i]=e/a&255;return t+n},s.prototype.writeUInt8=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,1,255,0),this[t]=255&e,t+1},s.prototype.writeUInt16LE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,2,65535,0),this[t]=255&e,this[t+1]=e>>>8,t+2},s.prototype.writeUInt16BE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=255&e,t+2},s.prototype.writeUInt32LE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e,t+4},s.prototype.writeUInt32BE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},s.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t>>>=0,!r){var i=Math.pow(2,8*n-1);R(this,e,t,n,i-1,-i)}var a=0,o=1,s=0;for(this[t]=255&e;++a>0)-s&255;return t+n},s.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t>>>=0,!r){var i=Math.pow(2,8*n-1);R(this,e,t,n,i-1,-i)}var a=n-1,o=1,s=0;for(this[t+a]=255&e;--a>=0&&(o*=256);)e<0&&0===s&&0!==this[t+a+1]&&(s=1),this[t+a]=(e/o>>0)-s&255;return t+n},s.prototype.writeInt8=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,1,127,-128),e<0&&(e=255+e+1),this[t]=255&e,t+1},s.prototype.writeInt16LE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,2,32767,-32768),this[t]=255&e,this[t+1]=e>>>8,t+2},s.prototype.writeInt16BE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=255&e,t+2},s.prototype.writeInt32LE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,4,2147483647,-2147483648),this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4},s.prototype.writeInt32BE=function(e,t,n){return e=+e,t>>>=0,n||R(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},s.prototype.writeFloatLE=function(e,t,n){return B(this,e,t,!0,n)},s.prototype.writeFloatBE=function(e,t,n){return B(this,e,t,!1,n)},s.prototype.writeDoubleLE=function(e,t,n){return L(this,e,t,!0,n)},s.prototype.writeDoubleBE=function(e,t,n){return L(this,e,t,!1,n)},s.prototype.copy=function(e,t,n,r){if(n||(n=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),r>0&&r=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t=0;--i)e[i+t]=this[i+n];else if(a<1e3)for(i=0;i>>=0,n=void 0===n?this.length:n>>>0,e||(e=0),"number"==typeof e)for(a=t;a55295&&n<57344){if(!i){if(n>56319){(t-=3)>-1&&a.push(239,191,189);continue}if(o+1===r){(t-=3)>-1&&a.push(239,191,189);continue}i=n;continue}if(n<56320){(t-=3)>-1&&a.push(239,191,189),i=n;continue}n=65536+(i-55296<<10|n-56320)}else i&&(t-=3)>-1&&a.push(239,191,189);if(i=null,n<128){if((t-=1)<0)break;a.push(n)}else if(n<2048){if((t-=2)<0)break;a.push(n>>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;a.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;a.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return a}function F(e){return r.toByteArray(function(e){if((e=e.trim().replace(O,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function N(e,t,n,r){for(var i=0;i=t.length||i>=e.length);++i)t[i+n]=e[i];return i}function P(e){return e instanceof ArrayBuffer||null!=e&&null!=e.constructor&&"ArrayBuffer"===e.constructor.name&&"number"==typeof e.byteLength}function U(e){return"function"==typeof ArrayBuffer.isView&&ArrayBuffer.isView(e)}function q(e){return e!=e}},{"base64-js":1,ieee754:55}],5:[function(e,t,n){(function(n){var r=e("tty"),i=e("./lib/encode"),a=e("stream").Stream,o=t.exports=function(){var e=null;function t(t){if(e)throw new Error("multiple inputs specified");e=t}var i=null;function a(e){if(i)throw new Error("multiple outputs specified");i=e}for(var o=0;o0&&this.down(t),e>0?this.right(e):e<0&&this.left(-e),this},s.prototype.up=function(e){return void 0===e&&(e=1),this.write(i("["+Math.floor(e)+"A")),this},s.prototype.down=function(e){return void 0===e&&(e=1),this.write(i("["+Math.floor(e)+"B")),this},s.prototype.right=function(e){return void 0===e&&(e=1),this.write(i("["+Math.floor(e)+"C")),this},s.prototype.left=function(e){return void 0===e&&(e=1),this.write(i("["+Math.floor(e)+"D")),this},s.prototype.column=function(e){return this.write(i("["+Math.floor(e)+"G")),this},s.prototype.push=function(e){return this.write(i(e?"7":"[s")),this},s.prototype.pop=function(e){return this.write(i(e?"8":"[u")),this},s.prototype.erase=function(e){return"end"===e||"$"===e?this.write(i("[K")):"start"===e||"^"===e?this.write(i("[1K")):"line"===e?this.write(i("[2K")):"down"===e?this.write(i("[J")):"up"===e?this.write(i("[1J")):"screen"===e?this.write(i("[1J")):this.emit("error",new Error("Unknown erase type: "+e)),this},s.prototype.display=function(e){var t={reset:0,bright:1,dim:2,underscore:4,blink:5,reverse:7,hidden:8}[e];return void 0===t&&this.emit("error",new Error("Unknown attribute: "+e)),this.write(i("["+t+"m")),this},s.prototype.foreground=function(e){if("number"==typeof e)(e<0||e>=256)&&this.emit("error",new Error("Color out of range: "+e)),this.write(i("[38;5;"+e+"m"));else{var t={black:30,red:31,green:32,yellow:33,blue:34,magenta:35,cyan:36,white:37}[e.toLowerCase()];t||this.emit("error",new Error("Unknown color: "+e)),this.write(i("["+t+"m"))}return this},s.prototype.background=function(e){if("number"==typeof e)(e<0||e>=256)&&this.emit("error",new Error("Color out of range: "+e)),this.write(i("[48;5;"+e+"m"));else{var t={black:40,red:41,green:42,yellow:43,blue:44,magenta:45,cyan:46,white:47}[e.toLowerCase()];t||this.emit("error",new Error("Unknown color: "+e)),this.write(i("["+t+"m"))}return this},s.prototype.cursor=function(e){return this.write(i(e?"[?25h":"[?25l")),this};var u=o.extractCodes=function(e){for(var t=[],n=-1,r=0;r=0&&t.push(e.slice(n,r)),n=r):n>=0&&r===e.length-1&&t.push(e.slice(n));return t}}).call(this,e("_process"))},{"./lib/encode":6,_process:98,stream:112,tty:129}],6:[function(e,t,n){(function(e){var n=(t.exports=function(t){return new e([27].concat(function e(t){return"string"==typeof t?t.split("").map(n):Array.isArray(t)?t.reduce(function(t,n){return t.concat(e(n))},[]):void 0}(t)))}).ord=function(e){return e.charCodeAt(0)}}).call(this,e("buffer").Buffer)},{buffer:4}],7:[function(e,t,n){(function(n){"use strict";var r=e("readable-stream").Readable,i=e("util");function a(e,t){if(!(this instanceof a))return new a(e,t);r.call(this,t),null!==e&&void 0!==e||(e=String(e)),this._obj=e}t.exports=a,i.inherits(a,r),a.prototype._read=function(e){var t=this._obj;"string"==typeof t?this.push(new n(t)):n.isBuffer(t)?this.push(t):this.push(new n(JSON.stringify(t))),this.push(null)}}).call(this,e("buffer").Buffer)},{buffer:4,"readable-stream":106,util:135}],8:[function(e,t,n){(function(e){function t(e){return Object.prototype.toString.call(e)}n.isArray=function(e){return Array.isArray?Array.isArray(e):"[object Array]"===t(e)},n.isBoolean=function(e){return"boolean"==typeof e},n.isNull=function(e){return null===e},n.isNullOrUndefined=function(e){return null==e},n.isNumber=function(e){return"number"==typeof e},n.isString=function(e){return"string"==typeof e},n.isSymbol=function(e){return"symbol"==typeof e},n.isUndefined=function(e){return void 0===e},n.isRegExp=function(e){return"[object RegExp]"===t(e)},n.isObject=function(e){return"object"==typeof e&&null!==e},n.isDate=function(e){return"[object Date]"===t(e)},n.isError=function(e){return"[object Error]"===t(e)||e instanceof Error},n.isFunction=function(e){return"function"==typeof e},n.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},n.isBuffer=e.isBuffer}).call(this,{isBuffer:e("../../is-buffer/index.js")})},{"../../is-buffer/index.js":59}],9:[function(e,t,n){"use strict";var r=e("./lib/thunk.js");t.exports=function(e){var t=new function(){this.argTypes=[],this.shimArgs=[],this.arrayArgs=[],this.arrayBlockIndices=[],this.scalarArgs=[],this.offsetArgs=[],this.offsetArgIndex=[],this.indexArgs=[],this.shapeArgs=[],this.funcName="",this.pre=null,this.body=null,this.post=null,this.debug=!1};t.pre=e.pre,t.body=e.body,t.post=e.post;var n=e.args.slice(0);t.argTypes=n;for(var i=0;i0)throw new Error("cwise: pre() block may not reference array args");if(i0)throw new Error("cwise: post() block may not reference array args")}else if("scalar"===a)t.scalarArgs.push(i),t.shimArgs.push("scalar"+i);else if("index"===a){if(t.indexArgs.push(i),i0)throw new Error("cwise: pre() block may not reference array index");if(i0)throw new Error("cwise: post() block may not reference array index")}else if("shape"===a){if(t.shapeArgs.push(i),in.length)throw new Error("cwise: Too many arguments in pre() block");if(t.body.args.length>n.length)throw new Error("cwise: Too many arguments in body() block");if(t.post.args.length>n.length)throw new Error("cwise: Too many arguments in post() block");return t.debug=!!e.printCode||!!e.debug,t.funcName=e.funcName||"cwise",t.blockSize=e.blockSize||64,r(t)}},{"./lib/thunk.js":11}],10:[function(e,t,n){"use strict";var r=e("uniq");function i(e,t,n){var r,i,a=e.length,o=t.arrayArgs.length,s=t.indexArgs.length>0,u=[],l=[],c=0,f=0;for(r=0;r0&&u.push("var "+l.join(",")),r=a-1;r>=0;--r)c=e[r],u.push(["for(i",r,"=0;i",r,"0&&u.push(["index[",f,"]-=s",f].join("")),u.push(["++index[",c,"]"].join(""))),u.push("}")}return u.join("\n")}function a(e,t,n){for(var r=e.body,i=[],a=[],o=0;o0&&_.push("shape=SS.slice(0)"),e.indexArgs.length>0){var w=new Array(n);for(u=0;u0&&m.push("var "+_.join(",")),u=0;u3&&m.push(a(e.pre,e,s));var k=a(e.body,e,s),E=function(e){for(var t=0,n=e[0].length;t0,l=[],c=0;c0;){"].join("")),l.push(["if(j",c,"<",s,"){"].join("")),l.push(["s",t[c],"=j",c].join("")),l.push(["j",c,"=0"].join("")),l.push(["}else{s",t[c],"=",s].join("")),l.push(["j",c,"-=",s,"}"].join("")),u&&l.push(["index[",t[c],"]=j",c].join(""));for(c=0;c3&&m.push(a(e.post,e,s)),e.debug&&console.log("-----Generated cwise routine for ",t,":\n"+m.join("\n")+"\n----------");var S=[e.funcName||"unnamed","_cwise_loop_",o[0].join("s"),"m",E,function(e){for(var t=new Array(e.length),n=!0,r=0;r0&&(n=n&&t[r]===t[r-1])}return n?t[0]:t.join("")}(s)].join("");return new Function(["function ",S,"(",v.join(","),"){",m.join("\n"),"} return ",S].join(""))()}},{uniq:131}],11:[function(e,t,n){"use strict";var r=e("./compile.js");t.exports=function(e){var t=["'use strict'","var CACHED={}"],n=[],i=e.funcName+"_cwise_thunk";t.push(["return function ",i,"(",e.shimArgs.join(","),"){"].join(""));for(var a=[],o=[],s=[["array",e.arrayArgs[0],".shape.slice(",Math.max(0,e.arrayBlockIndices[0]),e.arrayBlockIndices[0]<0?","+e.arrayBlockIndices[0]+")":")"].join("")],u=[],l=[],c=0;c0&&(u.push("array"+e.arrayArgs[0]+".shape.length===array"+f+".shape.length+"+(Math.abs(e.arrayBlockIndices[0])-Math.abs(e.arrayBlockIndices[c]))),l.push("array"+e.arrayArgs[0]+".shape[shapeIndex+"+Math.max(0,e.arrayBlockIndices[0])+"]===array"+f+".shape[shapeIndex+"+Math.max(0,e.arrayBlockIndices[c])+"]"))}for(e.arrayArgs.length>1&&(t.push("if (!("+u.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same dimensionality!')"),t.push("for(var shapeIndex=array"+e.arrayArgs[0]+".shape.length-"+Math.abs(e.arrayBlockIndices[0])+"; shapeIndex--\x3e0;) {"),t.push("if (!("+l.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same shape!')"),t.push("}")),c=0;c0)return function(e,t){var n,r;for(n=new Array(e),r=0;r 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],18:[function(e,t,n){t.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec4 uLens;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 TextureCoord2GLCoord(vec2 textureCoord) {\n\treturn (textureCoord - vec2(0.5, 0.5)) * 2.0;\n}\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord / 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tfloat correctionRadius = 0.5;\n\tfloat distance = sqrt(vPosition.x * vPosition.x + vPosition.y * vPosition.y) / correctionRadius;\n\tfloat theta = 1.0;\n\tif(distance != 0.0){\n\t\ttheta = atan(distance);\n\t}\n\tvec2 vMapping = theta * vPosition.xy;\n\tvMapping = GLCoord2TextureCoord(vMapping);\n\t\t\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],19:[function(e,t,n){t.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec3 uLensS;\nuniform vec2 uLensF;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord * vec2(1.0, -1.0)/ 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tfloat scale = uLensS.z;\n\tvec3 vPos = vPosition;\n\tfloat Fx = uLensF.x;\n\tfloat Fy = uLensF.y;\n\tvec2 vMapping = vPos.xy;\n\tvMapping.x = vMapping.x + ((pow(vPos.y, 2.0)/scale)*vPos.x/scale)*-Fx;\n\tvMapping.y = vMapping.y + ((pow(vPos.x, 2.0)/scale)*vPos.y/scale)*-Fy;\n\tvMapping = vMapping * uLensS.xy;\n\tvMapping = GLCoord2TextureCoord(vMapping/scale);\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t}\n\tgl_FragColor = texture;\n}\n"},{}],20:[function(e,t,n){t.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec4 uLens;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 TextureCoord2GLCoord(vec2 textureCoord) {\n\treturn (textureCoord - vec2(0.5, 0.5)) * 2.0;\n}\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord / 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tvec2 vMapping = vec2(vTextureCoord.x, 1.0 - vTextureCoord.y);\n\tvMapping = TextureCoord2GLCoord(vMapping);\n\t//TODO insert Code\n\tfloat F = uLens.x/ uLens.w;\n\tfloat seta = length(vMapping) / F;\n\tvMapping = sin(seta) * F / length(vMapping) * vMapping;\n\tvMapping *= uLens.w * 1.414;\n\tvMapping = GLCoord2TextureCoord(vMapping);\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],21:[function(e,t,n){t.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec4 uLens;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 TextureCoord2GLCoord(vec2 textureCoord) {\n\treturn (textureCoord - vec2(0.5, 0.5)) * 2.0;\n}\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord / 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tvec2 vMapping = vec2(vTextureCoord.x, 1.0 - vTextureCoord.y);\n\tvMapping = TextureCoord2GLCoord(vMapping);\n\t//TOD insert Code\n\tfloat F = uLens.x/ uLens.w;\n\tfloat seta = length(vMapping) / F;\n\tvMapping = sin(seta) * F / length(vMapping) * vMapping;\n\tvMapping *= uLens.w * 1.414;\n\tvMapping = GLCoord2TextureCoord(vMapping);\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],22:[function(e,t,n){t.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nattribute vec3 aVertexPosition;\nattribute vec2 aTextureCoord;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvoid main(void){\n\tvPosition = aVertexPosition;\n\tvTextureCoord = aTextureCoord;\n\tgl_Position = vec4(vPosition,1.0);\n}\n"},{}],23:[function(e,t,n){(function(n,r){"use strict";var i=e("path"),a=e("ndarray"),o=e("omggif").GifReader,s=(e("ndarray-pack"),e("through"),e("data-uri-to-buffer"));function u(e,t){var n;try{n=new o(e)}catch(e){return void t(e)}if(n.numFrames()>0){var r=[n.numFrames(),n.height,n.width,4],i=new Uint8Array(r[0]*r[1]*r[2]*r[3]),s=a(i,r);try{for(var u=0;u=0&&(this.dispose=e)},u.prototype.setRepeat=function(e){this.repeat=e},u.prototype.setTransparent=function(e){this.transparent=e},u.prototype.analyzeImage=function(e){this.setImagePixels(this.removeAlphaChannel(e)),this.analyzePixels()},u.prototype.writeImageInfo=function(){this.firstFrame&&(this.writeLSD(),this.writePalette(),this.repeat>=0&&this.writeNetscapeExt()),this.writeGraphicCtrlExt(),this.writeImageDesc(),this.firstFrame||this.writePalette(),this.firstFrame=!1},u.prototype.outputImage=function(){this.writePixels()},u.prototype.addFrame=function(e){this.emit("frame#start"),this.analyzeImage(e),this.writeImageInfo(),this.outputImage(),this.emit("frame#stop")},u.prototype.finish=function(){this.emit("finish#start"),this.writeByte(59),this.emit("finish#stop")},u.prototype.setQuality=function(e){e<1&&(e=1),this.sample=e},u.prototype.writeHeader=function(){this.emit("writeHeader#start"),this.writeUTFBytes("GIF89a"),this.emit("writeHeader#stop")},u.prototype.analyzePixels=function(){var e=this.pixels.length/3;this.indexedPixels=new Uint8Array(e);var t=new a(this.pixels,this.sample);t.buildColormap(),this.colorTab=t.getColormap();for(var n=0,r=0;r>16,n=(65280&e)>>8,r=255&e,i=0,a=16777216,o=this.colorTab.length,s=0;s=0&&(t=7&dispose),t<<=2,this.writeByte(0|t|e),this.writeShort(this.delay),this.writeByte(this.transIndex),this.writeByte(0)},u.prototype.writeImageDesc=function(){this.writeByte(44),this.writeShort(0),this.writeShort(0),this.writeShort(this.width),this.writeShort(this.height),this.firstFrame?this.writeByte(0):this.writeByte(128|this.palSize)},u.prototype.writeLSD=function(){this.writeShort(this.width),this.writeShort(this.height),this.writeByte(240|this.palSize),this.writeByte(0),this.writeByte(0)},u.prototype.writeNetscapeExt=function(){this.writeByte(33),this.writeByte(255),this.writeByte(11),this.writeUTFBytes("NETSCAPE2.0"),this.writeByte(3),this.writeByte(1),this.writeShort(this.repeat),this.writeByte(0)},u.prototype.writePalette=function(){this.writeBytes(this.colorTab);for(var e=768-this.colorTab.length,t=0;t>8&255)},u.prototype.writePixels=function(){new o(this.width,this.height,this.indexedPixels,this.colorDepth).encode(this)},u.prototype.stream=function(){return this},u.ByteCapacitor=s,t.exports=u}).call(this,e("buffer").Buffer)},{"./LZWEncoder.js":26,"./TypedNeuQuant.js":27,assert:36,buffer:4,events:43,"readable-stream":34,util:135}],26:[function(e,t,n){var r=-1,i=12,a=5003,o=[0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535];t.exports=function(e,t,n,s){var u,l,c,f,h,p,d,g,v,m=Math.max(2,s),_=new Uint8Array(256),w=new Int32Array(a),b=new Int32Array(a),y=0,x=0,k=!1;function E(e,t){_[l++]=e,l>=254&&M(t)}function S(e){A(a),x=g+2,k=!0,I(g,e)}function A(e){for(var t=0;t0&&(e.writeByte(l),e.writeBytes(_,0,l),l=0)}function T(e){return(1<0?u|=e<=8;)E(255&u,t),u>>=8,y-=8;if((x>c||k)&&(k?(c=T(p=d),k=!1):c=++p==i?1<0;)E(255&u,t),u>>=8,y-=8;M(t)}}this.encode=function(n){n.writeByte(m),f=e*t,h=0,function(e,t){var n,o,s,u,f,h,m;for(k=!1,c=T(p=d=e),v=1+(g=1<=0){f=h-s,0===s&&(f=1);do{if((s-=f)<0&&(s+=h),w[s]===n){u=b[s];continue e}}while(w[s]>=0)}I(u,t),u=o,x<1<>c,h=u<>3)*(1<l;)u=M[p++],fl&&((s=n[h--])[0]-=u*(s[0]-r)/_,s[1]-=u*(s[1]-a)/_,s[2]-=u*(s[2]-o)/_)}function I(e,t,r){var a,u,p,d,g,v=~(1<<31),m=v,_=-1,w=_;for(a=0;a>s-o))>c,A[a]-=g,S[a]+=g<>3),e=0;e>p;for(A<=1&&(A=0),n=0;n=c&&(R-=c),n++,0===_&&(_=1),n%_==0)for(E-=E/f,(A=(S-=S/g)>>p)<=1&&(A=0),l=0;l>=o,n[e][1]>>=o,n[e][2]>>=o,n[e][3]=e}(),function(){var e,t,r,o,s,u,l=0,c=0;for(e=0;e>1,t=l+1;t>1,t=l+1;t<256;t++)E[t]=a}()},this.getColormap=function(){for(var e=[],t=[],r=0;r=0;)c=u?c=i:(c++,s<0&&(s=-s),(a=o[0]-e)<0&&(a=-a),(s+=a)=0&&((s=t-(o=n[f])[1])>=u?f=-1:(f--,s<0&&(s=-s),(a=o[0]-e)<0&&(a=-a),(s+=a)0)if(t.ended&&!a){var s=new Error("stream.push() after EOF");e.emit("error",s)}else if(t.endEmitted&&a){s=new Error("stream.unshift() after end event");e.emit("error",s)}else!t.decoder||a||i||(r=t.decoder.write(r)),a||(t.reading=!1),t.flowing&&0===t.length&&!t.sync?(e.emit("data",r),e.read(0)):(t.length+=t.objectMode?1:r.length,a?t.buffer.unshift(r):t.buffer.push(r),t.needReadable&&g(e)),function(e,t){t.readingMore||(t.readingMore=!0,n.nextTick(function(){!function(e,t){var n=t.length;for(;!t.reading&&!t.flowing&&!t.ended&&t.lengtht.highWaterMark&&(t.highWaterMark=function(e){if(e>=p)e=p;else{e--;for(var t=1;t<32;t<<=1)e|=e>>t;e++}return e}(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function g(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(l("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?n.nextTick(function(){v(e)}):v(e))}function v(e){l("emit readable"),e.emit("readable"),m(e)}function m(e){var t=e._readableState;if(l("flow",t.flowing),t.flowing)do{var n=e.read()}while(null!==n&&t.flowing)}function _(e,t){var n,r=t.buffer,a=t.length,o=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===a)n=null;else if(s)n=r.shift();else if(!e||e>=a)n=o?r.join(""):i.concat(r,a),r.length=0;else{if(e0)throw new Error("endReadable called on non-empty stream");t.endEmitted||(t.ended=!0,n.nextTick(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}f.prototype.read=function(e){l("read",e);var t=this._readableState,n=e;if((!u.isNumber(e)||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return l("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?w(this):g(this),null;if(0===(e=d(e,t))&&t.ended)return 0===t.length&&w(this),null;var r,i=t.needReadable;return l("need readable",i),(0===t.length||t.length-e0?_(e,t):null,u.isNull(r)&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),n!==e&&t.ended&&0===t.length&&w(this),u.isNull(r)||this.emit("data",r),r},f.prototype._read=function(e){this.emit("error",new Error("not implemented"))},f.prototype.pipe=function(e,t){var i=this,o=this._readableState;switch(o.pipesCount){case 0:o.pipes=e;break;case 1:o.pipes=[o.pipes,e];break;default:o.pipes.push(e)}o.pipesCount+=1,l("pipe count=%d opts=%j",o.pipesCount,t);var s=(!t||!1!==t.end)&&e!==n.stdout&&e!==n.stderr?c:h;function u(e){l("onunpipe"),e===i&&h()}function c(){l("onend"),e.end()}o.endEmitted?n.nextTick(s):i.once("end",s),e.on("unpipe",u);var f=function(e){return function(){var t=e._readableState;l("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&a.listenerCount(e,"data")&&(t.flowing=!0,m(e))}}(i);function h(){l("cleanup"),e.removeListener("close",g),e.removeListener("finish",v),e.removeListener("drain",f),e.removeListener("error",d),e.removeListener("unpipe",u),i.removeListener("end",c),i.removeListener("end",h),i.removeListener("data",p),!o.awaitDrain||e._writableState&&!e._writableState.needDrain||f()}function p(t){l("ondata"),!1===e.write(t)&&(l("false write response, pause",i._readableState.awaitDrain),i._readableState.awaitDrain++,i.pause())}function d(t){l("onerror",t),_(),e.removeListener("error",d),0===a.listenerCount(e,"error")&&e.emit("error",t)}function g(){e.removeListener("finish",v),_()}function v(){l("onfinish"),e.removeListener("close",g),_()}function _(){l("unpipe"),i.unpipe(e)}return e.on("drain",f),i.on("data",p),e._events&&e._events.error?r(e._events.error)?e._events.error.unshift(d):e._events.error=[d,e._events.error]:e.on("error",d),e.once("close",g),e.once("finish",v),e.emit("pipe",i),o.flowing||(l("pipe resume"),i.resume()),e},f.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i1){for(var n=[],r=0;r=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,n),this.charReceived+=n,this.charReceived=55296&&i<=56319)){if(this.charReceived=this.charLength=0,0===e.length)return t;break}this.charLength+=this.surrogateSize,t=""}this.detectIncompleteChar(e);var r=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-this.charReceived,r),r-=this.charReceived);var i;r=(t+=e.toString(this.encoding,0,r)).length-1;if((i=t.charCodeAt(r))>=55296&&i<=56319){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),e.copy(this.charBuffer,0,0,a),t.substring(0,r)}return t},a.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(t<=2&&n>>4==14){this.charLength=3;break}if(t<=3&&n>>3==30){this.charLength=4;break}}this.charReceived=t},a.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,i=this.encoding;t+=r.slice(0,n).toString(i)}return t}},{buffer:4}],36:[function(e,t,n){(function(n){"use strict";function r(e,t){if(e===t)return 0;for(var n=e.length,r=t.length,i=0,a=Math.min(n,r);i=0;l--)if(c[l]!==f[l])return!1;for(l=c.length-1;l>=0;l--)if(u=c[l],!_(e[u],t[u],n,r))return!1;return!0}(e,t,n,o))}return n?e===t:e==t}function w(e){return"[object Arguments]"==Object.prototype.toString.call(e)}function b(e,t){if(!e||!t)return!1;if("[object RegExp]"==Object.prototype.toString.call(t))return t.test(e);try{if(e instanceof t)return!0}catch(e){}return!Error.isPrototypeOf(t)&&!0===t.call({},e)}function y(e,t,n,r){var i;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof n&&(r=n,n=null),i=function(e){var t;try{e()}catch(e){t=e}return t}(t),r=(n&&n.name?" ("+n.name+").":".")+(r?" "+r:"."),e&&!i&&v(i,n,"Missing expected exception"+r);var o="string"==typeof r,s=!e&&a.isError(i),u=!e&&i&&!n;if((s&&o&&b(i,n)||u)&&v(i,n,"Got unwanted exception"+r),e&&i&&n&&!b(i,n)||!e&&i)throw i}f.AssertionError=function(e){var t;this.name="AssertionError",this.actual=e.actual,this.expected=e.expected,this.operator=e.operator,e.message?(this.message=e.message,this.generatedMessage=!1):(this.message=d(g((t=this).actual),128)+" "+t.operator+" "+d(g(t.expected),128),this.generatedMessage=!0);var n=e.stackStartFunction||v;if(Error.captureStackTrace)Error.captureStackTrace(this,n);else{var r=new Error;if(r.stack){var i=r.stack,a=p(n),o=i.indexOf("\n"+a);if(o>=0){var s=i.indexOf("\n",o+1);i=i.substring(s+1)}this.stack=i}}},a.inherits(f.AssertionError,Error),f.fail=v,f.ok=m,f.equal=function(e,t,n){e!=t&&v(e,t,n,"==",f.equal)},f.notEqual=function(e,t,n){e==t&&v(e,t,n,"!=",f.notEqual)},f.deepEqual=function(e,t,n){_(e,t,!1)||v(e,t,n,"deepEqual",f.deepEqual)},f.deepStrictEqual=function(e,t,n){_(e,t,!0)||v(e,t,n,"deepStrictEqual",f.deepStrictEqual)},f.notDeepEqual=function(e,t,n){_(e,t,!1)&&v(e,t,n,"notDeepEqual",f.notDeepEqual)},f.notDeepStrictEqual=function e(t,n,r){_(t,n,!0)&&v(t,n,r,"notDeepStrictEqual",e)},f.strictEqual=function(e,t,n){e!==t&&v(e,t,n,"===",f.strictEqual)},f.notStrictEqual=function(e,t,n){e===t&&v(e,t,n,"!==",f.notStrictEqual)},f.throws=function(e,t,n){y(!0,e,t,n)},f.doesNotThrow=function(e,t,n){y(!1,e,t,n)},f.ifError=function(e){if(e)throw e};var x=Object.keys||function(e){var t=[];for(var n in e)o.call(e,n)&&t.push(n);return t}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"util/":39}],37:[function(e,t,n){"function"==typeof Object.create?t.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},{}],38:[function(e,t,n){t.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{}],39:[function(e,t,n){(function(t,r){var i=/%[sdj%]/g;n.format=function(e){if(!m(e)){for(var t=[],n=0;n=a)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(e){return"[Circular]"}default:return e}}),u=r[n];n=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),d(t)?r.showHidden=t:t&&n._extend(r,t),_(r.showHidden)&&(r.showHidden=!1),_(r.depth)&&(r.depth=2),_(r.colors)&&(r.colors=!1),_(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=u),c(r,e,r.depth)}function u(e,t){var n=s.styles[t];return n?"["+s.colors[n][0]+"m"+e+"["+s.colors[n][1]+"m":e}function l(e,t){return e}function c(e,t,r){if(e.customInspect&&t&&k(t.inspect)&&t.inspect!==n.inspect&&(!t.constructor||t.constructor.prototype!==t)){var i=t.inspect(r,e);return m(i)||(i=c(e,i,r)),i}var a=function(e,t){if(_(t))return e.stylize("undefined","undefined");if(m(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}if(v(t))return e.stylize(""+t,"number");if(d(t))return e.stylize(""+t,"boolean");if(g(t))return e.stylize("null","null")}(e,t);if(a)return a;var o=Object.keys(t),s=function(e){var t={};return e.forEach(function(e,n){t[e]=!0}),t}(o);if(e.showHidden&&(o=Object.getOwnPropertyNames(t)),x(t)&&(o.indexOf("message")>=0||o.indexOf("description")>=0))return f(t);if(0===o.length){if(k(t)){var u=t.name?": "+t.name:"";return e.stylize("[Function"+u+"]","special")}if(w(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(y(t))return e.stylize(Date.prototype.toString.call(t),"date");if(x(t))return f(t)}var l,b="",E=!1,S=["{","}"];(p(t)&&(E=!0,S=["[","]"]),k(t))&&(b=" [Function"+(t.name?": "+t.name:"")+"]");return w(t)&&(b=" "+RegExp.prototype.toString.call(t)),y(t)&&(b=" "+Date.prototype.toUTCString.call(t)),x(t)&&(b=" "+f(t)),0!==o.length||E&&0!=t.length?r<0?w(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special"):(e.seen.push(t),l=E?function(e,t,n,r,i){for(var a=[],o=0,s=t.length;o=0&&0,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0)>60)return n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+n[1];return n[0]+t+" "+e.join(", ")+" "+n[1]}(l,b,S)):S[0]+b+S[1]}function f(e){return"["+Error.prototype.toString.call(e)+"]"}function h(e,t,n,r,i,a){var o,s,u;if((u=Object.getOwnPropertyDescriptor(t,i)||{value:t[i]}).get?s=u.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):u.set&&(s=e.stylize("[Setter]","special")),M(r,i)||(o="["+i+"]"),s||(e.seen.indexOf(u.value)<0?(s=g(n)?c(e,u.value,null):c(e,u.value,n-1)).indexOf("\n")>-1&&(s=a?s.split("\n").map(function(e){return" "+e}).join("\n").substr(2):"\n"+s.split("\n").map(function(e){return" "+e}).join("\n")):s=e.stylize("[Circular]","special")),_(o)){if(a&&i.match(/^\d+$/))return s;(o=JSON.stringify(""+i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(o=o.substr(1,o.length-2),o=e.stylize(o,"name")):(o=o.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),o=e.stylize(o,"string"))}return o+": "+s}function p(e){return Array.isArray(e)}function d(e){return"boolean"==typeof e}function g(e){return null===e}function v(e){return"number"==typeof e}function m(e){return"string"==typeof e}function _(e){return void 0===e}function w(e){return b(e)&&"[object RegExp]"===E(e)}function b(e){return"object"==typeof e&&null!==e}function y(e){return b(e)&&"[object Date]"===E(e)}function x(e){return b(e)&&("[object Error]"===E(e)||e instanceof Error)}function k(e){return"function"==typeof e}function E(e){return Object.prototype.toString.call(e)}function S(e){return e<10?"0"+e.toString(10):e.toString(10)}n.debuglog=function(e){if(_(a)&&(a=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!o[e])if(new RegExp("\\b"+e+"\\b","i").test(a)){var r=t.pid;o[e]=function(){var t=n.format.apply(n,arguments);console.error("%s %d: %s",e,r,t)}}else o[e]=function(){};return o[e]},n.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},n.isArray=p,n.isBoolean=d,n.isNull=g,n.isNullOrUndefined=function(e){return null==e},n.isNumber=v,n.isString=m,n.isSymbol=function(e){return"symbol"==typeof e},n.isUndefined=_,n.isRegExp=w,n.isObject=b,n.isDate=y,n.isError=x,n.isFunction=k,n.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},n.isBuffer=e("./support/isBuffer");var A=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function M(e,t){return Object.prototype.hasOwnProperty.call(e,t)}n.log=function(){var e,t;console.log("%s - %s",(e=new Date,t=[S(e.getHours()),S(e.getMinutes()),S(e.getSeconds())].join(":"),[e.getDate(),A[e.getMonth()],t].join(" ")),n.format.apply(n,arguments))},n.inherits=e("inherits"),n._extend=function(e,t){if(!t||!b(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e}}).call(this,e("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":38,_process:98,inherits:37}],40:[function(e,t,n){(function(t,r){"use strict";var i=e("assert"),a=e("pako/lib/zlib/zstream"),o=e("pako/lib/zlib/deflate.js"),s=e("pako/lib/zlib/inflate.js"),u=e("pako/lib/zlib/constants");for(var l in u)n[l]=u[l];n.NONE=0,n.DEFLATE=1,n.INFLATE=2,n.GZIP=3,n.GUNZIP=4,n.DEFLATERAW=5,n.INFLATERAW=6,n.UNZIP=7;function c(e){if("number"!=typeof e||en.UNZIP)throw new TypeError("Bad argument");this.dictionary=null,this.err=0,this.flush=0,this.init_done=!1,this.level=0,this.memLevel=0,this.mode=e,this.strategy=0,this.windowBits=0,this.write_in_progress=!1,this.pending_close=!1,this.gzip_id_bytes_read=0}c.prototype.close=function(){this.write_in_progress?this.pending_close=!0:(this.pending_close=!1,i(this.init_done,"close before init"),i(this.mode<=n.UNZIP),this.mode===n.DEFLATE||this.mode===n.GZIP||this.mode===n.DEFLATERAW?o.deflateEnd(this.strm):this.mode!==n.INFLATE&&this.mode!==n.GUNZIP&&this.mode!==n.INFLATERAW&&this.mode!==n.UNZIP||s.inflateEnd(this.strm),this.mode=n.NONE,this.dictionary=null)},c.prototype.write=function(e,t,n,r,i,a,o){return this._write(!0,e,t,n,r,i,a,o)},c.prototype.writeSync=function(e,t,n,r,i,a,o){return this._write(!1,e,t,n,r,i,a,o)},c.prototype._write=function(e,a,o,s,u,l,c,f){if(i.equal(arguments.length,8),i(this.init_done,"write before init"),i(this.mode!==n.NONE,"already finalized"),i.equal(!1,this.write_in_progress,"write already in progress"),i.equal(!1,this.pending_close,"close is pending"),this.write_in_progress=!0,i.equal(!1,void 0===a,"must provide flush value"),this.write_in_progress=!0,a!==n.Z_NO_FLUSH&&a!==n.Z_PARTIAL_FLUSH&&a!==n.Z_SYNC_FLUSH&&a!==n.Z_FULL_FLUSH&&a!==n.Z_FINISH&&a!==n.Z_BLOCK)throw new Error("Invalid flush value");if(null==o&&(o=r.alloc(0),u=0,s=0),this.strm.avail_in=u,this.strm.input=o,this.strm.next_in=s,this.strm.avail_out=f,this.strm.output=l,this.strm.next_out=c,this.flush=a,!e)return this._process(),this._checkError()?this._afterSync():void 0;var h=this;return t.nextTick(function(){h._process(),h._after()}),this},c.prototype._afterSync=function(){var e=this.strm.avail_out,t=this.strm.avail_in;return this.write_in_progress=!1,[t,e]},c.prototype._process=function(){var e=null;switch(this.mode){case n.DEFLATE:case n.GZIP:case n.DEFLATERAW:this.err=o.deflate(this.strm,this.flush);break;case n.UNZIP:switch(this.strm.avail_in>0&&(e=this.strm.next_in),this.gzip_id_bytes_read){case 0:if(null===e)break;if(31!==this.strm.input[e]){this.mode=n.INFLATE;break}if(this.gzip_id_bytes_read=1,e++,1===this.strm.avail_in)break;case 1:if(null===e)break;139===this.strm.input[e]?(this.gzip_id_bytes_read=2,this.mode=n.GUNZIP):this.mode=n.INFLATE;break;default:throw new Error("invalid number of gzip magic number bytes read")}case n.INFLATE:case n.GUNZIP:case n.INFLATERAW:for(this.err=s.inflate(this.strm,this.flush),this.err===n.Z_NEED_DICT&&this.dictionary&&(this.err=s.inflateSetDictionary(this.strm,this.dictionary),this.err===n.Z_OK?this.err=s.inflate(this.strm,this.flush):this.err===n.Z_DATA_ERROR&&(this.err=n.Z_NEED_DICT));this.strm.avail_in>0&&this.mode===n.GUNZIP&&this.err===n.Z_STREAM_END&&0!==this.strm.next_in[0];)this.reset(),this.err=s.inflate(this.strm,this.flush);break;default:throw new Error("Unknown mode "+this.mode)}},c.prototype._checkError=function(){switch(this.err){case n.Z_OK:case n.Z_BUF_ERROR:if(0!==this.strm.avail_out&&this.flush===n.Z_FINISH)return this._error("unexpected end of file"),!1;break;case n.Z_STREAM_END:break;case n.Z_NEED_DICT:return null==this.dictionary?this._error("Missing dictionary"):this._error("Bad dictionary"),!1;default:return this._error("Zlib error"),!1}return!0},c.prototype._after=function(){if(this._checkError()){var e=this.strm.avail_out,t=this.strm.avail_in;this.write_in_progress=!1,this.callback(t,e),this.pending_close&&this.close()}},c.prototype._error=function(e){this.strm.msg&&(e=this.strm.msg),this.onerror(e,this.err),this.write_in_progress=!1,this.pending_close&&this.close()},c.prototype.init=function(e,t,r,a,o){i(4===arguments.length||5===arguments.length,"init(windowBits, level, memLevel, strategy, [dictionary])"),i(e>=8&&e<=15,"invalid windowBits"),i(t>=-1&&t<=9,"invalid compression level"),i(r>=1&&r<=9,"invalid memlevel"),i(a===n.Z_FILTERED||a===n.Z_HUFFMAN_ONLY||a===n.Z_RLE||a===n.Z_FIXED||a===n.Z_DEFAULT_STRATEGY,"invalid strategy"),this._init(t,e,r,a,o),this._setDictionary()},c.prototype.params=function(){throw new Error("deflateParams Not supported")},c.prototype.reset=function(){this._reset(),this._setDictionary()},c.prototype._init=function(e,t,r,i,u){switch(this.level=e,this.windowBits=t,this.memLevel=r,this.strategy=i,this.flush=n.Z_NO_FLUSH,this.err=n.Z_OK,this.mode!==n.GZIP&&this.mode!==n.GUNZIP||(this.windowBits+=16),this.mode===n.UNZIP&&(this.windowBits+=32),this.mode!==n.DEFLATERAW&&this.mode!==n.INFLATERAW||(this.windowBits=-1*this.windowBits),this.strm=new a,this.mode){case n.DEFLATE:case n.GZIP:case n.DEFLATERAW:this.err=o.deflateInit2(this.strm,this.level,n.Z_DEFLATED,this.windowBits,this.memLevel,this.strategy);break;case n.INFLATE:case n.GUNZIP:case n.INFLATERAW:case n.UNZIP:this.err=s.inflateInit2(this.strm,this.windowBits);break;default:throw new Error("Unknown mode "+this.mode)}this.err!==n.Z_OK&&this._error("Init error"),this.dictionary=u,this.write_in_progress=!1,this.init_done=!0},c.prototype._setDictionary=function(){if(null!=this.dictionary){switch(this.err=n.Z_OK,this.mode){case n.DEFLATE:case n.DEFLATERAW:this.err=o.deflateSetDictionary(this.strm,this.dictionary)}this.err!==n.Z_OK&&this._error("Failed to set dictionary")}},c.prototype._reset=function(){switch(this.err=n.Z_OK,this.mode){case n.DEFLATE:case n.DEFLATERAW:case n.GZIP:this.err=o.deflateReset(this.strm);break;case n.INFLATE:case n.INFLATERAW:case n.GUNZIP:this.err=s.inflateReset(this.strm)}this.err!==n.Z_OK&&this._error("Failed to reset stream")},n.Zlib=c}).call(this,e("_process"),e("buffer").Buffer)},{_process:98,assert:36,buffer:4,"pako/lib/zlib/constants":46,"pako/lib/zlib/deflate.js":48,"pako/lib/zlib/inflate.js":50,"pako/lib/zlib/zstream":54}],41:[function(e,t,n){(function(t){"use strict";var r=e("buffer").Buffer,i=e("stream").Transform,a=e("./binding"),o=e("util"),s=e("assert").ok,u=e("buffer").kMaxLength,l="Cannot create final Buffer. It would be larger than 0x"+u.toString(16)+" bytes";a.Z_MIN_WINDOWBITS=8,a.Z_MAX_WINDOWBITS=15,a.Z_DEFAULT_WINDOWBITS=15,a.Z_MIN_CHUNK=64,a.Z_MAX_CHUNK=1/0,a.Z_DEFAULT_CHUNK=16384,a.Z_MIN_MEMLEVEL=1,a.Z_MAX_MEMLEVEL=9,a.Z_DEFAULT_MEMLEVEL=8,a.Z_MIN_LEVEL=-1,a.Z_MAX_LEVEL=9,a.Z_DEFAULT_LEVEL=a.Z_DEFAULT_COMPRESSION;for(var c=Object.keys(a),f=0;f=u?o=new RangeError(l):t=r.concat(i,a),i=[],e.close(),n(o,t)}e.on("error",function(t){e.removeListener("end",s),e.removeListener("readable",o),n(t)}),e.on("end",s),e.end(t),o()}function _(e,t){if("string"==typeof t&&(t=r.from(t)),!r.isBuffer(t))throw new TypeError("Not a string or buffer");var n=e._finishFlushFlag;return e._processChunk(t,n)}function w(e){if(!(this instanceof w))return new w(e);M.call(this,e,a.DEFLATE)}function b(e){if(!(this instanceof b))return new b(e);M.call(this,e,a.INFLATE)}function y(e){if(!(this instanceof y))return new y(e);M.call(this,e,a.GZIP)}function x(e){if(!(this instanceof x))return new x(e);M.call(this,e,a.GUNZIP)}function k(e){if(!(this instanceof k))return new k(e);M.call(this,e,a.DEFLATERAW)}function E(e){if(!(this instanceof E))return new E(e);M.call(this,e,a.INFLATERAW)}function S(e){if(!(this instanceof S))return new S(e);M.call(this,e,a.UNZIP)}function A(e){return e===a.Z_NO_FLUSH||e===a.Z_PARTIAL_FLUSH||e===a.Z_SYNC_FLUSH||e===a.Z_FULL_FLUSH||e===a.Z_FINISH||e===a.Z_BLOCK}function M(e,t){var o=this;if(this._opts=e=e||{},this._chunkSize=e.chunkSize||n.Z_DEFAULT_CHUNK,i.call(this,e),e.flush&&!A(e.flush))throw new Error("Invalid flush flag: "+e.flush);if(e.finishFlush&&!A(e.finishFlush))throw new Error("Invalid flush flag: "+e.finishFlush);if(this._flushFlag=e.flush||a.Z_NO_FLUSH,this._finishFlushFlag=void 0!==e.finishFlush?e.finishFlush:a.Z_FINISH,e.chunkSize&&(e.chunkSizen.Z_MAX_CHUNK))throw new Error("Invalid chunk size: "+e.chunkSize);if(e.windowBits&&(e.windowBitsn.Z_MAX_WINDOWBITS))throw new Error("Invalid windowBits: "+e.windowBits);if(e.level&&(e.leveln.Z_MAX_LEVEL))throw new Error("Invalid compression level: "+e.level);if(e.memLevel&&(e.memLeveln.Z_MAX_MEMLEVEL))throw new Error("Invalid memLevel: "+e.memLevel);if(e.strategy&&e.strategy!=n.Z_FILTERED&&e.strategy!=n.Z_HUFFMAN_ONLY&&e.strategy!=n.Z_RLE&&e.strategy!=n.Z_FIXED&&e.strategy!=n.Z_DEFAULT_STRATEGY)throw new Error("Invalid strategy: "+e.strategy);if(e.dictionary&&!r.isBuffer(e.dictionary))throw new Error("Invalid dictionary: it should be a Buffer instance");this._handle=new a.Zlib(t);var s=this;this._hadError=!1,this._handle.onerror=function(e,t){T(s),s._hadError=!0;var r=new Error(e);r.errno=t,r.code=n.codes[t],s.emit("error",r)};var u=n.Z_DEFAULT_COMPRESSION;"number"==typeof e.level&&(u=e.level);var l=n.Z_DEFAULT_STRATEGY;"number"==typeof e.strategy&&(l=e.strategy),this._handle.init(e.windowBits||n.Z_DEFAULT_WINDOWBITS,u,e.memLevel||n.Z_DEFAULT_MEMLEVEL,l,e.dictionary),this._buffer=r.allocUnsafe(this._chunkSize),this._offset=0,this._level=u,this._strategy=l,this.once("end",this.close),Object.defineProperty(this,"_closed",{get:function(){return!o._handle},configurable:!0,enumerable:!0})}function T(e,n){n&&t.nextTick(n),e._handle&&(e._handle.close(),e._handle=null)}function j(e){e.emit("close")}Object.defineProperty(n,"codes",{enumerable:!0,value:Object.freeze(p),writable:!1}),n.Deflate=w,n.Inflate=b,n.Gzip=y,n.Gunzip=x,n.DeflateRaw=k,n.InflateRaw=E,n.Unzip=S,n.createDeflate=function(e){return new w(e)},n.createInflate=function(e){return new b(e)},n.createDeflateRaw=function(e){return new k(e)},n.createInflateRaw=function(e){return new E(e)},n.createGzip=function(e){return new y(e)},n.createGunzip=function(e){return new x(e)},n.createUnzip=function(e){return new S(e)},n.deflate=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new w(t),e,n)},n.deflateSync=function(e,t){return _(new w(t),e)},n.gzip=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new y(t),e,n)},n.gzipSync=function(e,t){return _(new y(t),e)},n.deflateRaw=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new k(t),e,n)},n.deflateRawSync=function(e,t){return _(new k(t),e)},n.unzip=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new S(t),e,n)},n.unzipSync=function(e,t){return _(new S(t),e)},n.inflate=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new b(t),e,n)},n.inflateSync=function(e,t){return _(new b(t),e)},n.gunzip=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new x(t),e,n)},n.gunzipSync=function(e,t){return _(new x(t),e)},n.inflateRaw=function(e,t,n){return"function"==typeof t&&(n=t,t={}),m(new E(t),e,n)},n.inflateRawSync=function(e,t){return _(new E(t),e)},o.inherits(M,i),M.prototype.params=function(e,r,i){if(en.Z_MAX_LEVEL)throw new RangeError("Invalid compression level: "+e);if(r!=n.Z_FILTERED&&r!=n.Z_HUFFMAN_ONLY&&r!=n.Z_RLE&&r!=n.Z_FIXED&&r!=n.Z_DEFAULT_STRATEGY)throw new TypeError("Invalid strategy: "+r);if(this._level!==e||this._strategy!==r){var o=this;this.flush(a.Z_SYNC_FLUSH,function(){s(o._handle,"zlib binding closed"),o._handle.params(e,r),o._hadError||(o._level=e,o._strategy=r,i&&i())})}else t.nextTick(i)},M.prototype.reset=function(){return s(this._handle,"zlib binding closed"),this._handle.reset()},M.prototype._flush=function(e){this._transform(r.alloc(0),"",e)},M.prototype.flush=function(e,n){var i=this,o=this._writableState;("function"==typeof e||void 0===e&&!n)&&(n=e,e=a.Z_FULL_FLUSH),o.ended?n&&t.nextTick(n):o.ending?n&&this.once("end",n):o.needDrain?n&&this.once("drain",function(){return i.flush(e,n)}):(this._flushFlag=e,this.write(r.alloc(0),"",n))},M.prototype.close=function(e){T(this,e),t.nextTick(j,this)},M.prototype._transform=function(e,t,n){var i,o=this._writableState,s=(o.ending||o.ended)&&(!e||o.length===e.length);return null===e||r.isBuffer(e)?this._handle?(s?i=this._finishFlushFlag:(i=this._flushFlag,e.length>=o.length&&(this._flushFlag=this._opts.flush||a.Z_NO_FLUSH)),void this._processChunk(e,i,n)):n(new Error("zlib binding closed")):n(new Error("invalid input"))},M.prototype._processChunk=function(e,t,n){var i=e&&e.length,a=this._chunkSize-this._offset,o=0,c=this,f="function"==typeof n;if(!f){var h,p=[],d=0;this.on("error",function(e){h=e}),s(this._handle,"zlib binding closed");do{var g=this._handle.writeSync(t,e,o,i,this._buffer,this._offset,a)}while(!this._hadError&&_(g[0],g[1]));if(this._hadError)throw h;if(d>=u)throw T(this),new RangeError(l);var v=r.concat(p,d);return T(this),v}s(this._handle,"zlib binding closed");var m=this._handle.write(t,e,o,i,this._buffer,this._offset,a);function _(u,l){if(this&&(this.buffer=null,this.callback=null),!c._hadError){var h=a-l;if(s(h>=0,"have should not go down"),h>0){var g=c._buffer.slice(c._offset,c._offset+h);c._offset+=h,f?c.push(g):(p.push(g),d+=g.length)}if((0===l||c._offset>=c._chunkSize)&&(a=c._chunkSize,c._offset=0,c._buffer=r.allocUnsafe(c._chunkSize)),0===l){if(o+=i-u,i=u,!f)return!0;var v=c._handle.write(t,e,o,i,c._buffer,c._offset,c._chunkSize);return v.callback=_,void(v.buffer=e)}if(!f)return!1;n()}}m.buffer=e,m.callback=_},o.inherits(w,M),o.inherits(b,M),o.inherits(y,M),o.inherits(x,M),o.inherits(k,M),o.inherits(E,M),o.inherits(S,M)}).call(this,e("_process"))},{"./binding":40,_process:98,assert:36,buffer:4,stream:112,util:135}],42:[function(e,t,n){arguments[4][3][0].apply(n,arguments)},{dup:3}],43:[function(e,t,n){var r=Object.create||function(e){var t=function(){};return t.prototype=e,new t},i=Object.keys||function(e){var t=[];for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.push(n);return n},a=Function.prototype.bind||function(e){var t=this;return function(){return t.apply(e,arguments)}};function o(){this._events&&Object.prototype.hasOwnProperty.call(this,"_events")||(this._events=r(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0}t.exports=o,o.EventEmitter=o,o.prototype._events=void 0,o.prototype._maxListeners=void 0;var s,u=10;try{var l={};Object.defineProperty&&Object.defineProperty(l,"x",{value:0}),s=0===l.x}catch(e){s=!1}function c(e){return void 0===e._maxListeners?o.defaultMaxListeners:e._maxListeners}function f(e,t,n,i){var a,o,s;if("function"!=typeof n)throw new TypeError('"listener" argument must be a function');if((o=e._events)?(o.newListener&&(e.emit("newListener",t,n.listener?n.listener:n),o=e._events),s=o[t]):(o=e._events=r(null),e._eventsCount=0),s){if("function"==typeof s?s=o[t]=i?[n,s]:[s,n]:i?s.unshift(n):s.push(n),!s.warned&&(a=c(e))&&a>0&&s.length>a){s.warned=!0;var u=new Error("Possible EventEmitter memory leak detected. "+s.length+' "'+String(t)+'" listeners added. Use emitter.setMaxListeners() to increase limit.');u.name="MaxListenersExceededWarning",u.emitter=e,u.type=t,u.count=s.length,"object"==typeof console&&console.warn&&console.warn("%s: %s",u.name,u.message)}}else s=o[t]=n,++e._eventsCount;return e}function h(){if(!this.fired)switch(this.target.removeListener(this.type,this.wrapFn),this.fired=!0,arguments.length){case 0:return this.listener.call(this.target);case 1:return this.listener.call(this.target,arguments[0]);case 2:return this.listener.call(this.target,arguments[0],arguments[1]);case 3:return this.listener.call(this.target,arguments[0],arguments[1],arguments[2]);default:for(var e=new Array(arguments.length),t=0;t1&&(t=arguments[1]),t instanceof Error)throw t;var u=new Error('Unhandled "error" event. ('+t+")");throw u.context=t,u}if(!(n=o[e]))return!1;var l="function"==typeof n;switch(r=arguments.length){case 1:!function(e,t,n){if(t)e.call(n);else for(var r=e.length,i=v(e,r),a=0;a=0;o--)if(n[o]===t||n[o].listener===t){s=n[o].listener,a=o;break}if(a<0)return this;0===a?n.shift():function(e,t){for(var n=t,r=n+1,i=e.length;r=0;a--)this.removeListener(e,t[a]);return this},o.prototype.listeners=function(e){return d(this,e,!0)},o.prototype.rawListeners=function(e){return d(this,e,!1)},o.listenerCount=function(e,t){return"function"==typeof e.listenerCount?e.listenerCount(t):g.call(e,t)},o.prototype.listenerCount=g,o.prototype.eventNames=function(){return this._eventsCount>0?Reflect.ownKeys(this._events):[]}},{}],44:[function(e,t,n){"use strict";var r="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Int32Array;function i(e,t){return Object.prototype.hasOwnProperty.call(e,t)}n.assign=function(e){for(var t=Array.prototype.slice.call(arguments,1);t.length;){var n=t.shift();if(n){if("object"!=typeof n)throw new TypeError(n+"must be non-object");for(var r in n)i(n,r)&&(e[r]=n[r])}}return e},n.shrinkBuf=function(e,t){return e.length===t?e:e.subarray?e.subarray(0,t):(e.length=t,e)};var a={arraySet:function(e,t,n,r,i){if(t.subarray&&e.subarray)e.set(t.subarray(n,n+r),i);else for(var a=0;a>>16&65535|0,o=0;0!==n;){n-=o=n>2e3?2e3:n;do{a=a+(i=i+t[r++]|0)|0}while(--o);i%=65521,a%=65521}return i|a<<16|0}},{}],46:[function(e,t,n){"use strict";t.exports={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,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_BUF_ERROR:-5,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,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8}},{}],47:[function(e,t,n){"use strict";var r=function(){for(var e,t=[],n=0;n<256;n++){e=n;for(var r=0;r<8;r++)e=1&e?3988292384^e>>>1:e>>>1;t[n]=e}return t}();t.exports=function(e,t,n,i){var a=r,o=i+n;e^=-1;for(var s=i;s>>8^a[255&(e^t[s])];return-1^e}},{}],48:[function(e,t,n){"use strict";var r,i=e("../utils/common"),a=e("./trees"),o=e("./adler32"),s=e("./crc32"),u=e("./messages"),l=0,c=1,f=3,h=4,p=5,d=0,g=1,v=-2,m=-3,_=-5,w=-1,b=1,y=2,x=3,k=4,E=0,S=2,A=8,M=9,T=15,j=8,I=286,R=30,C=19,B=2*I+1,L=15,O=3,z=258,D=z+O+1,F=32,N=42,P=69,U=73,q=91,V=103,Z=113,W=666,G=1,H=2,Y=3,$=4,X=3;function J(e,t){return e.msg=u[t],t}function K(e){return(e<<1)-(e>4?9:0)}function Q(e){for(var t=e.length;--t>=0;)e[t]=0}function ee(e){var t=e.state,n=t.pending;n>e.avail_out&&(n=e.avail_out),0!==n&&(i.arraySet(e.output,t.pending_buf,t.pending_out,n,e.next_out),e.next_out+=n,t.pending_out+=n,e.total_out+=n,e.avail_out-=n,t.pending-=n,0===t.pending&&(t.pending_out=0))}function te(e,t){a._tr_flush_block(e,e.block_start>=0?e.block_start:-1,e.strstart-e.block_start,t),e.block_start=e.strstart,ee(e.strm)}function ne(e,t){e.pending_buf[e.pending++]=t}function re(e,t){e.pending_buf[e.pending++]=t>>>8&255,e.pending_buf[e.pending++]=255&t}function ie(e,t){var n,r,i=e.max_chain_length,a=e.strstart,o=e.prev_length,s=e.nice_match,u=e.strstart>e.w_size-D?e.strstart-(e.w_size-D):0,l=e.window,c=e.w_mask,f=e.prev,h=e.strstart+z,p=l[a+o-1],d=l[a+o];e.prev_length>=e.good_match&&(i>>=2),s>e.lookahead&&(s=e.lookahead);do{if(l[(n=t)+o]===d&&l[n+o-1]===p&&l[n]===l[a]&&l[++n]===l[a+1]){a+=2,n++;do{}while(l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&ao){if(e.match_start=t,o=r,r>=s)break;p=l[a+o-1],d=l[a+o]}}}while((t=f[t&c])>u&&0!=--i);return o<=e.lookahead?o:e.lookahead}function ae(e){var t,n,r,a,u,l,c,f,h,p,d=e.w_size;do{if(a=e.window_size-e.lookahead-e.strstart,e.strstart>=d+(d-D)){i.arraySet(e.window,e.window,d,d,0),e.match_start-=d,e.strstart-=d,e.block_start-=d,t=n=e.hash_size;do{r=e.head[--t],e.head[t]=r>=d?r-d:0}while(--n);t=n=d;do{r=e.prev[--t],e.prev[t]=r>=d?r-d:0}while(--n);a+=d}if(0===e.strm.avail_in)break;if(l=e.strm,c=e.window,f=e.strstart+e.lookahead,h=a,p=void 0,(p=l.avail_in)>h&&(p=h),n=0===p?0:(l.avail_in-=p,i.arraySet(c,l.input,l.next_in,p,f),1===l.state.wrap?l.adler=o(l.adler,c,p,f):2===l.state.wrap&&(l.adler=s(l.adler,c,p,f)),l.next_in+=p,l.total_in+=p,p),e.lookahead+=n,e.lookahead+e.insert>=O)for(u=e.strstart-e.insert,e.ins_h=e.window[u],e.ins_h=(e.ins_h<=O&&(e.ins_h=(e.ins_h<=O)if(r=a._tr_tally(e,e.strstart-e.match_start,e.match_length-O),e.lookahead-=e.match_length,e.match_length<=e.max_lazy_match&&e.lookahead>=O){e.match_length--;do{e.strstart++,e.ins_h=(e.ins_h<=O&&(e.ins_h=(e.ins_h<4096)&&(e.match_length=O-1)),e.prev_length>=O&&e.match_length<=e.prev_length){i=e.strstart+e.lookahead-O,r=a._tr_tally(e,e.strstart-1-e.prev_match,e.prev_length-O),e.lookahead-=e.prev_length-1,e.prev_length-=2;do{++e.strstart<=i&&(e.ins_h=(e.ins_h<15&&(s=2,r-=16),a<1||a>M||n!==A||r<8||r>15||t<0||t>9||o<0||o>k)return J(e,v);8===r&&(r=9);var u=new function(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=A,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new i.Buf16(2*B),this.dyn_dtree=new i.Buf16(2*(2*R+1)),this.bl_tree=new i.Buf16(2*(2*C+1)),Q(this.dyn_ltree),Q(this.dyn_dtree),Q(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new i.Buf16(L+1),this.heap=new i.Buf16(2*I+1),Q(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new i.Buf16(2*I+1),Q(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0};return e.state=u,u.strm=e,u.wrap=s,u.gzhead=null,u.w_bits=r,u.w_size=1<e.pending_buf_size-5&&(n=e.pending_buf_size-5);;){if(e.lookahead<=1){if(ae(e),0===e.lookahead&&t===l)return G;if(0===e.lookahead)break}e.strstart+=e.lookahead,e.lookahead=0;var r=e.block_start+n;if((0===e.strstart||e.strstart>=r)&&(e.lookahead=e.strstart-r,e.strstart=r,te(e,!1),0===e.strm.avail_out))return G;if(e.strstart-e.block_start>=e.w_size-D&&(te(e,!1),0===e.strm.avail_out))return G}return e.insert=0,t===h?(te(e,!0),0===e.strm.avail_out?Y:$):(e.strstart>e.block_start&&(te(e,!1),e.strm.avail_out),G)}),new ue(4,4,8,4,oe),new ue(4,5,16,8,oe),new ue(4,6,32,32,oe),new ue(4,4,16,16,se),new ue(8,16,32,32,se),new ue(8,16,128,128,se),new ue(8,32,128,256,se),new ue(32,128,258,1024,se),new ue(32,258,258,4096,se)],n.deflateInit=function(e,t){return fe(e,t,A,T,j,E)},n.deflateInit2=fe,n.deflateReset=ce,n.deflateResetKeep=le,n.deflateSetHeader=function(e,t){return e&&e.state?2!==e.state.wrap?v:(e.state.gzhead=t,d):v},n.deflate=function(e,t){var n,i,o,u;if(!e||!e.state||t>p||t<0)return e?J(e,v):v;if(i=e.state,!e.output||!e.input&&0!==e.avail_in||i.status===W&&t!==h)return J(e,0===e.avail_out?_:v);if(i.strm=e,n=i.last_flush,i.last_flush=t,i.status===N)if(2===i.wrap)e.adler=0,ne(i,31),ne(i,139),ne(i,8),i.gzhead?(ne(i,(i.gzhead.text?1:0)+(i.gzhead.hcrc?2:0)+(i.gzhead.extra?4:0)+(i.gzhead.name?8:0)+(i.gzhead.comment?16:0)),ne(i,255&i.gzhead.time),ne(i,i.gzhead.time>>8&255),ne(i,i.gzhead.time>>16&255),ne(i,i.gzhead.time>>24&255),ne(i,9===i.level?2:i.strategy>=y||i.level<2?4:0),ne(i,255&i.gzhead.os),i.gzhead.extra&&i.gzhead.extra.length&&(ne(i,255&i.gzhead.extra.length),ne(i,i.gzhead.extra.length>>8&255)),i.gzhead.hcrc&&(e.adler=s(e.adler,i.pending_buf,i.pending,0)),i.gzindex=0,i.status=P):(ne(i,0),ne(i,0),ne(i,0),ne(i,0),ne(i,0),ne(i,9===i.level?2:i.strategy>=y||i.level<2?4:0),ne(i,X),i.status=Z);else{var m=A+(i.w_bits-8<<4)<<8;m|=(i.strategy>=y||i.level<2?0:i.level<6?1:6===i.level?2:3)<<6,0!==i.strstart&&(m|=F),m+=31-m%31,i.status=Z,re(i,m),0!==i.strstart&&(re(i,e.adler>>>16),re(i,65535&e.adler)),e.adler=1}if(i.status===P)if(i.gzhead.extra){for(o=i.pending;i.gzindex<(65535&i.gzhead.extra.length)&&(i.pending!==i.pending_buf_size||(i.gzhead.hcrc&&i.pending>o&&(e.adler=s(e.adler,i.pending_buf,i.pending-o,o)),ee(e),o=i.pending,i.pending!==i.pending_buf_size));)ne(i,255&i.gzhead.extra[i.gzindex]),i.gzindex++;i.gzhead.hcrc&&i.pending>o&&(e.adler=s(e.adler,i.pending_buf,i.pending-o,o)),i.gzindex===i.gzhead.extra.length&&(i.gzindex=0,i.status=U)}else i.status=U;if(i.status===U)if(i.gzhead.name){o=i.pending;do{if(i.pending===i.pending_buf_size&&(i.gzhead.hcrc&&i.pending>o&&(e.adler=s(e.adler,i.pending_buf,i.pending-o,o)),ee(e),o=i.pending,i.pending===i.pending_buf_size)){u=1;break}u=i.gzindexo&&(e.adler=s(e.adler,i.pending_buf,i.pending-o,o)),0===u&&(i.gzindex=0,i.status=q)}else i.status=q;if(i.status===q)if(i.gzhead.comment){o=i.pending;do{if(i.pending===i.pending_buf_size&&(i.gzhead.hcrc&&i.pending>o&&(e.adler=s(e.adler,i.pending_buf,i.pending-o,o)),ee(e),o=i.pending,i.pending===i.pending_buf_size)){u=1;break}u=i.gzindexo&&(e.adler=s(e.adler,i.pending_buf,i.pending-o,o)),0===u&&(i.status=V)}else i.status=V;if(i.status===V&&(i.gzhead.hcrc?(i.pending+2>i.pending_buf_size&&ee(e),i.pending+2<=i.pending_buf_size&&(ne(i,255&e.adler),ne(i,e.adler>>8&255),e.adler=0,i.status=Z)):i.status=Z),0!==i.pending){if(ee(e),0===e.avail_out)return i.last_flush=-1,d}else if(0===e.avail_in&&K(t)<=K(n)&&t!==h)return J(e,_);if(i.status===W&&0!==e.avail_in)return J(e,_);if(0!==e.avail_in||0!==i.lookahead||t!==l&&i.status!==W){var w=i.strategy===y?function(e,t){for(var n;;){if(0===e.lookahead&&(ae(e),0===e.lookahead)){if(t===l)return G;break}if(e.match_length=0,n=a._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++,n&&(te(e,!1),0===e.strm.avail_out))return G}return e.insert=0,t===h?(te(e,!0),0===e.strm.avail_out?Y:$):e.last_lit&&(te(e,!1),0===e.strm.avail_out)?G:H}(i,t):i.strategy===x?function(e,t){for(var n,r,i,o,s=e.window;;){if(e.lookahead<=z){if(ae(e),e.lookahead<=z&&t===l)return G;if(0===e.lookahead)break}if(e.match_length=0,e.lookahead>=O&&e.strstart>0&&(r=s[i=e.strstart-1])===s[++i]&&r===s[++i]&&r===s[++i]){o=e.strstart+z;do{}while(r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&ie.lookahead&&(e.match_length=e.lookahead)}if(e.match_length>=O?(n=a._tr_tally(e,1,e.match_length-O),e.lookahead-=e.match_length,e.strstart+=e.match_length,e.match_length=0):(n=a._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++),n&&(te(e,!1),0===e.strm.avail_out))return G}return e.insert=0,t===h?(te(e,!0),0===e.strm.avail_out?Y:$):e.last_lit&&(te(e,!1),0===e.strm.avail_out)?G:H}(i,t):r[i.level].func(i,t);if(w!==Y&&w!==$||(i.status=W),w===G||w===Y)return 0===e.avail_out&&(i.last_flush=-1),d;if(w===H&&(t===c?a._tr_align(i):t!==p&&(a._tr_stored_block(i,0,0,!1),t===f&&(Q(i.head),0===i.lookahead&&(i.strstart=0,i.block_start=0,i.insert=0))),ee(e),0===e.avail_out))return i.last_flush=-1,d}return t!==h?d:i.wrap<=0?g:(2===i.wrap?(ne(i,255&e.adler),ne(i,e.adler>>8&255),ne(i,e.adler>>16&255),ne(i,e.adler>>24&255),ne(i,255&e.total_in),ne(i,e.total_in>>8&255),ne(i,e.total_in>>16&255),ne(i,e.total_in>>24&255)):(re(i,e.adler>>>16),re(i,65535&e.adler)),ee(e),i.wrap>0&&(i.wrap=-i.wrap),0!==i.pending?d:g)},n.deflateEnd=function(e){var t;return e&&e.state?(t=e.state.status)!==N&&t!==P&&t!==U&&t!==q&&t!==V&&t!==Z&&t!==W?J(e,v):(e.state=null,t===Z?J(e,m):d):v},n.deflateSetDictionary=function(e,t){var n,r,a,s,u,l,c,f,h=t.length;if(!e||!e.state)return v;if(2===(s=(n=e.state).wrap)||1===s&&n.status!==N||n.lookahead)return v;for(1===s&&(e.adler=o(e.adler,t,h,0)),n.wrap=0,h>=n.w_size&&(0===s&&(Q(n.head),n.strstart=0,n.block_start=0,n.insert=0),f=new i.Buf8(n.w_size),i.arraySet(f,t,h-n.w_size,n.w_size,0),t=f,h=n.w_size),u=e.avail_in,l=e.next_in,c=e.input,e.avail_in=h,e.next_in=0,e.input=t,ae(n);n.lookahead>=O;){r=n.strstart,a=n.lookahead-(O-1);do{n.ins_h=(n.ins_h<>>=b=w>>>24,d-=b,0===(b=w>>>16&255))A[a++]=65535&w;else{if(!(16&b)){if(0==(64&b)){w=g[(65535&w)+(p&(1<>>=b,d-=b),d<15&&(p+=S[r++]<>>=b=w>>>24,d-=b,!(16&(b=w>>>16&255))){if(0==(64&b)){w=v[(65535&w)+(p&(1<u){e.msg="invalid distance too far back",n.mode=30;break e}if(p>>>=b,d-=b,x>(b=a-o)){if((b=x-b)>c&&n.sane){e.msg="invalid distance too far back",n.mode=30;break e}if(k=0,E=h,0===f){if(k+=l-b,b2;)A[a++]=E[k++],A[a++]=E[k++],A[a++]=E[k++],y-=3;y&&(A[a++]=E[k++],y>1&&(A[a++]=E[k++]))}else{k=a-x;do{A[a++]=A[k++],A[a++]=A[k++],A[a++]=A[k++],y-=3}while(y>2);y&&(A[a++]=A[k++],y>1&&(A[a++]=A[k++]))}break}}break}}while(r>3,p&=(1<<(d-=y<<3))-1,e.next_in=r,e.next_out=a,e.avail_in=r>>24&255)+(e>>>8&65280)+((65280&e)<<8)+((255&e)<<24)}function ie(e){var t;return e&&e.state?(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=1&t.wrap),t.mode=x,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new r.Buf32(ee),t.distcode=t.distdyn=new r.Buf32(te),t.sane=1,t.back=-1,d):m}function ae(e){var t;return e&&e.state?((t=e.state).wsize=0,t.whave=0,t.wnext=0,ie(e)):m}function oe(e,t){var n,r;return e&&e.state?(r=e.state,t<0?(n=0,t=-t):(n=1+(t>>4),t<48&&(t&=15)),t&&(t<8||t>15)?m:(null!==r.window&&r.wbits!==t&&(r.window=null),r.wrap=n,r.wbits=t,ae(e))):m}function se(e,t){var n,i;return e?(i=new function(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new r.Buf16(320),this.work=new r.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0},e.state=i,i.window=null,(n=oe(e,t))!==d&&(e.state=null),n):m}var ue,le,ce=!0;function fe(e){if(ce){var t;for(ue=new r.Buf32(512),le=new r.Buf32(32),t=0;t<144;)e.lens[t++]=8;for(;t<256;)e.lens[t++]=9;for(;t<280;)e.lens[t++]=7;for(;t<288;)e.lens[t++]=8;for(s(l,e.lens,0,288,ue,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;s(c,e.lens,0,32,le,0,e.work,{bits:5}),ce=!1}e.lencode=ue,e.lenbits=9,e.distcode=le,e.distbits=5}function he(e,t,n,i){var a,o=e.state;return null===o.window&&(o.wsize=1<=o.wsize?(r.arraySet(o.window,t,n-o.wsize,o.wsize,0),o.wnext=0,o.whave=o.wsize):((a=o.wsize-o.wnext)>i&&(a=i),r.arraySet(o.window,t,n-i,a,o.wnext),(i-=a)?(r.arraySet(o.window,t,n-i,i,0),o.wnext=i,o.whave=o.wsize):(o.wnext+=a,o.wnext===o.wsize&&(o.wnext=0),o.whave>>8&255,n.check=a(n.check,Me,2,0),se=0,ue=0,n.mode=k;break}if(n.flags=0,n.head&&(n.head.done=!1),!(1&n.wrap)||(((255&se)<<8)+(se>>8))%31){e.msg="incorrect header check",n.mode=J;break}if((15&se)!==y){e.msg="unknown compression method",n.mode=J;break}if(ue-=4,xe=8+(15&(se>>>=4)),0===n.wbits)n.wbits=xe;else if(xe>n.wbits){e.msg="invalid window size",n.mode=J;break}n.dmax=1<>8&1),512&n.flags&&(Me[0]=255&se,Me[1]=se>>>8&255,n.check=a(n.check,Me,2,0)),se=0,ue=0,n.mode=E;case E:for(;ue<32;){if(0===ae)break e;ae--,se+=ee[ne++]<>>8&255,Me[2]=se>>>16&255,Me[3]=se>>>24&255,n.check=a(n.check,Me,4,0)),se=0,ue=0,n.mode=S;case S:for(;ue<16;){if(0===ae)break e;ae--,se+=ee[ne++]<>8),512&n.flags&&(Me[0]=255&se,Me[1]=se>>>8&255,n.check=a(n.check,Me,2,0)),se=0,ue=0,n.mode=A;case A:if(1024&n.flags){for(;ue<16;){if(0===ae)break e;ae--,se+=ee[ne++]<>>8&255,n.check=a(n.check,Me,2,0)),se=0,ue=0}else n.head&&(n.head.extra=null);n.mode=M;case M:if(1024&n.flags&&((pe=n.length)>ae&&(pe=ae),pe&&(n.head&&(xe=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),r.arraySet(n.head.extra,ee,ne,pe,xe)),512&n.flags&&(n.check=a(n.check,ee,pe,ne)),ae-=pe,ne+=pe,n.length-=pe),n.length))break e;n.length=0,n.mode=T;case T:if(2048&n.flags){if(0===ae)break e;pe=0;do{xe=ee[ne+pe++],n.head&&xe&&n.length<65536&&(n.head.name+=String.fromCharCode(xe))}while(xe&&pe>9&1,n.head.done=!0),e.adler=n.check=0,n.mode=B;break;case R:for(;ue<32;){if(0===ae)break e;ae--,se+=ee[ne++]<>>=7&ue,ue-=7&ue,n.mode=Y;break}for(;ue<3;){if(0===ae)break e;ae--,se+=ee[ne++]<>>=1)){case 0:n.mode=O;break;case 1:if(fe(n),n.mode=U,t===p){se>>>=2,ue-=2;break e}break;case 2:n.mode=F;break;case 3:e.msg="invalid block type",n.mode=J}se>>>=2,ue-=2;break;case O:for(se>>>=7&ue,ue-=7&ue;ue<32;){if(0===ae)break e;ae--,se+=ee[ne++]<>>16^65535)){e.msg="invalid stored block lengths",n.mode=J;break}if(n.length=65535&se,se=0,ue=0,n.mode=z,t===p)break e;case z:n.mode=D;case D:if(pe=n.length){if(pe>ae&&(pe=ae),pe>oe&&(pe=oe),0===pe)break e;r.arraySet(te,ee,ne,pe,ie),ae-=pe,ne+=pe,oe-=pe,ie+=pe,n.length-=pe;break}n.mode=B;break;case F:for(;ue<14;){if(0===ae)break e;ae--,se+=ee[ne++]<>>=5,ue-=5,n.ndist=1+(31&se),se>>>=5,ue-=5,n.ncode=4+(15&se),se>>>=4,ue-=4,n.nlen>286||n.ndist>30){e.msg="too many length or distance symbols",n.mode=J;break}n.have=0,n.mode=N;case N:for(;n.have>>=3,ue-=3}for(;n.have<19;)n.lens[Te[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,Ee={bits:n.lenbits},ke=s(u,n.lens,0,19,n.lencode,0,n.work,Ee),n.lenbits=Ee.bits,ke){e.msg="invalid code lengths set",n.mode=J;break}n.have=0,n.mode=P;case P:for(;n.have>>16&255,_e=65535&Ae,!((ve=Ae>>>24)<=ue);){if(0===ae)break e;ae--,se+=ee[ne++]<>>=ve,ue-=ve,n.lens[n.have++]=_e;else{if(16===_e){for(Se=ve+2;ue>>=ve,ue-=ve,0===n.have){e.msg="invalid bit length repeat",n.mode=J;break}xe=n.lens[n.have-1],pe=3+(3&se),se>>>=2,ue-=2}else if(17===_e){for(Se=ve+3;ue>>=ve)),se>>>=3,ue-=3}else{for(Se=ve+7;ue>>=ve)),se>>>=7,ue-=7}if(n.have+pe>n.nlen+n.ndist){e.msg="invalid bit length repeat",n.mode=J;break}for(;pe--;)n.lens[n.have++]=xe}}if(n.mode===J)break;if(0===n.lens[256]){e.msg="invalid code -- missing end-of-block",n.mode=J;break}if(n.lenbits=9,Ee={bits:n.lenbits},ke=s(l,n.lens,0,n.nlen,n.lencode,0,n.work,Ee),n.lenbits=Ee.bits,ke){e.msg="invalid literal/lengths set",n.mode=J;break}if(n.distbits=6,n.distcode=n.distdyn,Ee={bits:n.distbits},ke=s(c,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,Ee),n.distbits=Ee.bits,ke){e.msg="invalid distances set",n.mode=J;break}if(n.mode=U,t===p)break e;case U:n.mode=q;case q:if(ae>=6&&oe>=258){e.next_out=ie,e.avail_out=oe,e.next_in=ne,e.avail_in=ae,n.hold=se,n.bits=ue,o(e,ce),ie=e.next_out,te=e.output,oe=e.avail_out,ne=e.next_in,ee=e.input,ae=e.avail_in,se=n.hold,ue=n.bits,n.mode===B&&(n.back=-1);break}for(n.back=0;me=(Ae=n.lencode[se&(1<>>16&255,_e=65535&Ae,!((ve=Ae>>>24)<=ue);){if(0===ae)break e;ae--,se+=ee[ne++]<>we)])>>>16&255,_e=65535&Ae,!(we+(ve=Ae>>>24)<=ue);){if(0===ae)break e;ae--,se+=ee[ne++]<>>=we,ue-=we,n.back+=we}if(se>>>=ve,ue-=ve,n.back+=ve,n.length=_e,0===me){n.mode=H;break}if(32&me){n.back=-1,n.mode=B;break}if(64&me){e.msg="invalid literal/length code",n.mode=J;break}n.extra=15&me,n.mode=V;case V:if(n.extra){for(Se=n.extra;ue>>=n.extra,ue-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=Z;case Z:for(;me=(Ae=n.distcode[se&(1<>>16&255,_e=65535&Ae,!((ve=Ae>>>24)<=ue);){if(0===ae)break e;ae--,se+=ee[ne++]<>we)])>>>16&255,_e=65535&Ae,!(we+(ve=Ae>>>24)<=ue);){if(0===ae)break e;ae--,se+=ee[ne++]<>>=we,ue-=we,n.back+=we}if(se>>>=ve,ue-=ve,n.back+=ve,64&me){e.msg="invalid distance code",n.mode=J;break}n.offset=_e,n.extra=15&me,n.mode=W;case W:if(n.extra){for(Se=n.extra;ue>>=n.extra,ue-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){e.msg="invalid distance too far back",n.mode=J;break}n.mode=G;case G:if(0===oe)break e;if(pe=ce-oe,n.offset>pe){if((pe=n.offset-pe)>n.whave&&n.sane){e.msg="invalid distance too far back",n.mode=J;break}pe>n.wnext?(pe-=n.wnext,de=n.wsize-pe):de=n.wnext-pe,pe>n.length&&(pe=n.length),ge=n.window}else ge=te,de=ie-n.offset,pe=n.length;pe>oe&&(pe=oe),oe-=pe,n.length-=pe;do{te[ie++]=ge[de++]}while(--pe);0===n.length&&(n.mode=q);break;case H:if(0===oe)break e;te[ie++]=n.length,oe--,n.mode=q;break;case Y:if(n.wrap){for(;ue<32;){if(0===ae)break e;ae--,se|=ee[ne++]<=1&&0===O[A];A--);if(M>A&&(M=A),0===A)return l[c++]=20971520,l[c++]=20971520,h.bits=1,0;for(S=1;S0&&(0===e||1!==A))return-1;for(z[1]=0,k=1;k<15;k++)z[k+1]=z[k]+O[k];for(E=0;E852||2===e&&R>592)return 1;for(;;){w=k-j,f[E]<_?(b=0,y=f[E]):f[E]>_?(b=D[F+f[E]],y=B[L+f[E]]):(b=96,y=0),p=1<>j)+(d-=p)]=w<<24|b<<16|y|0}while(0!==d);for(p=1<>=1;if(0!==p?(C&=p-1,C+=p):C=0,E++,0==--O[k]){if(k===A)break;k=t[n+f[E]]}if(k>M&&(C&v)!==g){for(0===j&&(j=M),m+=S,I=1<<(T=k-j);T+j852||2===e&&R>592)return 1;l[g=C&v]=M<<24|T<<16|m-c|0}}return 0!==C&&(l[m+C]=k-j<<24|64<<16|0),h.bits=M,0}},{"../utils/common":44}],52:[function(e,t,n){"use strict";t.exports={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"}},{}],53:[function(e,t,n){"use strict";var r=e("../utils/common"),i=4,a=0,o=1,s=2;function u(e){for(var t=e.length;--t>=0;)e[t]=0}var l=0,c=1,f=2,h=29,p=256,d=p+1+h,g=30,v=19,m=2*d+1,_=15,w=16,b=7,y=256,x=16,k=17,E=18,S=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],A=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],M=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],T=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],j=new Array(2*(d+2));u(j);var I=new Array(2*g);u(I);var R=new Array(512);u(R);var C=new Array(256);u(C);var B=new Array(h);u(B);var L,O,z,D=new Array(g);function F(e,t,n,r,i){this.static_tree=e,this.extra_bits=t,this.extra_base=n,this.elems=r,this.max_length=i,this.has_stree=e&&e.length}function N(e,t){this.dyn_tree=e,this.max_code=0,this.stat_desc=t}function P(e){return e<256?R[e]:R[256+(e>>>7)]}function U(e,t){e.pending_buf[e.pending++]=255&t,e.pending_buf[e.pending++]=t>>>8&255}function q(e,t,n){e.bi_valid>w-n?(e.bi_buf|=t<>w-e.bi_valid,e.bi_valid+=n-w):(e.bi_buf|=t<>>=1,n<<=1}while(--t>0);return n>>>1}function W(e,t,n){var r,i,a=new Array(_+1),o=0;for(r=1;r<=_;r++)a[r]=o=o+n[r-1]<<1;for(i=0;i<=t;i++){var s=e[2*i+1];0!==s&&(e[2*i]=Z(a[s]++,s))}}function G(e){var t;for(t=0;t8?U(e,e.bi_buf):e.bi_valid>0&&(e.pending_buf[e.pending++]=e.bi_buf),e.bi_buf=0,e.bi_valid=0}function Y(e,t,n,r){var i=2*t,a=2*n;return e[i]>1;n>=1;n--)$(e,a,n);i=u;do{n=e.heap[1],e.heap[1]=e.heap[e.heap_len--],$(e,a,1),r=e.heap[1],e.heap[--e.heap_max]=n,e.heap[--e.heap_max]=r,a[2*i]=a[2*n]+a[2*r],e.depth[i]=(e.depth[n]>=e.depth[r]?e.depth[n]:e.depth[r])+1,a[2*n+1]=a[2*r+1]=i,e.heap[1]=i++,$(e,a,1)}while(e.heap_len>=2);e.heap[--e.heap_max]=e.heap[1],function(e,t){var n,r,i,a,o,s,u=t.dyn_tree,l=t.max_code,c=t.stat_desc.static_tree,f=t.stat_desc.has_stree,h=t.stat_desc.extra_bits,p=t.stat_desc.extra_base,d=t.stat_desc.max_length,g=0;for(a=0;a<=_;a++)e.bl_count[a]=0;for(u[2*e.heap[e.heap_max]+1]=0,n=e.heap_max+1;nd&&(a=d,g++),u[2*r+1]=a,r>l||(e.bl_count[a]++,o=0,r>=p&&(o=h[r-p]),s=u[2*r],e.opt_len+=s*(a+o),f&&(e.static_len+=s*(c[2*r+1]+o)));if(0!==g){do{for(a=d-1;0===e.bl_count[a];)a--;e.bl_count[a]--,e.bl_count[a+1]+=2,e.bl_count[d]--,g-=2}while(g>0);for(a=d;0!==a;a--)for(r=e.bl_count[a];0!==r;)(i=e.heap[--n])>l||(u[2*i+1]!==a&&(e.opt_len+=(a-u[2*i+1])*u[2*i],u[2*i+1]=a),r--)}}(e,t),W(a,l,e.bl_count)}function K(e,t,n){var r,i,a=-1,o=t[1],s=0,u=7,l=4;for(0===o&&(u=138,l=3),t[2*(n+1)+1]=65535,r=0;r<=n;r++)i=o,o=t[2*(r+1)+1],++s>=7;r0?(e.strm.data_type===s&&(e.strm.data_type=function(e){var t,n=4093624447;for(t=0;t<=31;t++,n>>>=1)if(1&n&&0!==e.dyn_ltree[2*t])return a;if(0!==e.dyn_ltree[18]||0!==e.dyn_ltree[20]||0!==e.dyn_ltree[26])return o;for(t=32;t=3&&0===e.bl_tree[2*T[t]+1];t--);return e.opt_len+=3*(t+1)+5+5+4,t}(e),u=e.opt_len+3+7>>>3,(l=e.static_len+3+7>>>3)<=u&&(u=l)):u=l=n+5,n+4<=u&&-1!==t?te(e,t,n,r):e.strategy===i||l===u?(q(e,(c<<1)+(r?1:0),3),X(e,j,I)):(q(e,(f<<1)+(r?1:0),3),function(e,t,n,r){var i;for(q(e,t-257,5),q(e,n-1,5),q(e,r-4,4),i=0;i>>8&255,e.pending_buf[e.d_buf+2*e.last_lit+1]=255&t,e.pending_buf[e.l_buf+e.last_lit]=255&n,e.last_lit++,0===t?e.dyn_ltree[2*n]++:(e.matches++,t--,e.dyn_ltree[2*(C[n]+p+1)]++,e.dyn_dtree[2*P(t)]++),e.last_lit===e.lit_bufsize-1},n._tr_align=function(e){q(e,c<<1,3),V(e,y,j),function(e){16===e.bi_valid?(U(e,e.bi_buf),e.bi_buf=0,e.bi_valid=0):e.bi_valid>=8&&(e.pending_buf[e.pending++]=255&e.bi_buf,e.bi_buf>>=8,e.bi_valid-=8)}(e)}},{"../utils/common":44}],54:[function(e,t,n){"use strict";t.exports=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}},{}],55:[function(e,t,n){n.read=function(e,t,n,r,i){var a,o,s=8*i-r-1,u=(1<>1,c=-7,f=n?i-1:0,h=n?-1:1,p=e[t+f];for(f+=h,a=p&(1<<-c)-1,p>>=-c,c+=s;c>0;a=256*a+e[t+f],f+=h,c-=8);for(o=a&(1<<-c)-1,a>>=-c,c+=r;c>0;o=256*o+e[t+f],f+=h,c-=8);if(0===a)a=1-l;else{if(a===u)return o?NaN:1/0*(p?-1:1);o+=Math.pow(2,r),a-=l}return(p?-1:1)*o*Math.pow(2,a-r)},n.write=function(e,t,n,r,i,a){var o,s,u,l=8*a-i-1,c=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=r?0:a-1,d=r?1:-1,g=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,o=c):(o=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-o))<1&&(o--,u*=2),(t+=o+f>=1?h/u:h*Math.pow(2,1-f))*u>=2&&(o++,u/=2),o+f>=c?(s=0,o=c):o+f>=1?(s=(t*u-1)*Math.pow(2,i),o+=f):(s=t*Math.pow(2,f-1)*Math.pow(2,i),o=0));i>=8;e[n+p]=255&s,p+=d,s/=256,i-=8);for(o=o<0;e[n+p]=255&o,p+=d,o/=256,l-=8);e[n+p-d]|=128*g}},{}],56:[function(e,t,n){t.exports=[function(e,t){return{options:e,draw:function(t,n,r){r.stop(!0),r.overrideFlag=!0;var i=this;return t.pixelManipulation({output:function(e,t,n){i.output={src:t,format:n}},changePixel:function(e,t,n,r){return[255-e,255-t,255-n,r]},format:t.format,image:e.image,inBrowser:e.inBrowser,callback:n})},output:void 0,UI:t}},{name:"Invert",description:"Inverts the image.",inputs:{}}]},{}],57:[function(e,t,n){arguments[4][37][0].apply(n,arguments)},{dup:37}],58:[function(e,t,n){"use strict";t.exports=function(e){for(var t=new Array(e),n=0;n>i;0!=(t&o)&&p++;var d=n>>i;return 0!=(n&o)&&d++,function(e,t,n,o,s,u){function l(e,t,n){return en?n:e}var c=r.BitMatrix.createEmpty(o,s);function f(e,t,n,r,i){for(var o=n*i+t,s=0;sd&&(p=d);for(var g=0;gm&&(v=m);for(var _=l(g,2,t-3),w=l(h,2,n-3),b=0,y=-2;y<=2;y++){var x=u[w+y];b+=x[_-2],b+=x[_-1],b+=x[_],b+=x[_+1],b+=x[_+2]}f(e,v,p,b/25,o)}}return c}(u,p,d,t,n,function(e,t,n,r,o){for(var u=new Array(n),l=0;lh&&(f=h);for(var p=0;pg&&(d=g);for(var v=0,m=255,_=0,w=0,b=f*r+d;w_&&(_=x)}if(_-m>s)for(w++,b+=r;w>2*i;if(_-m<=s&&(k=m>>1,c>0&&p>0)){var E=u[c-1][p]+2*u[c][p-1]+u[c-1][p-1]>>2;m=n&&(e++,r+=t.estimatedModuleSize)}),e<3)return!1;for(var a=r/i,o=0,s=0;s=0&&c(n,l);)o[2]++,l--;if(l<0)return null;for(;l>=0&&!c(n,l)&&o[1]<=r;)o[1]++,l--;if(l<0||o[1]>r)return null;for(;l>=0&&c(n,l)&&o[0]<=r;)o[0]++,l--;if(o[0]>r)return null;for(l=t+1;l=r)return null;for(;l=r)return null;var f=o[0]+o[1]+o[2]+o[3]+o[4];return 5*Math.abs(f-i)>=2*i?null:s(o)?u(o,l):null}(r,Math.floor(f),n[2],l);if(null!=h&&null!=(f=function(t,n,r,i){for(var a=e.width,o=[0,0,0,0,0],l=t;l>=0&&c(l,n);)o[2]++,l--;if(l<0)return null;for(;l>=0&&!c(l,n)&&o[1]<=r;)o[1]++,l--;if(l<0||o[1]>r)return null;for(;l>=0&&c(l,n)&&o[0]<=r;)o[0]++,l--;if(o[0]>r)return null;for(l=t+1;l=r)return null;for(;l=r)return null;var f=o[0]+o[1]+o[2]+o[3]+o[4];return 5*Math.abs(f-i)>=i?null:s(o)?u(o,l):null}(Math.floor(f),Math.floor(h),n[2],l))&&(!a||function(t,n,r,i){for(var a=e.height,o=e.width,u=[0,0,0,0,0],l=0;t-l>=0&&c(n-l,t-l);)u[2]++,l++;if(t-l<0||n-l<0)return!1;for(;t-l>=0&&n-l>=0&&!c(n-l,t-l)&&u[1]<=r;)u[1]++,l++;if(t-l<0||n-l<0||u[1]>r)return!1;for(;t-l>=0&&n-l>=0&&c(n-l,t-l)&&u[0]<=r;)u[0]++,l++;if(u[0]>r)return!1;for(l=1;t+l=a||n+l>=o)return!1;for(;t+l=a||n+l>=o||u[3]>=r)return!1;for(;t+l=r)return!1;var f=u[0]+u[1]+u[2]+u[3]+u[4];return Math.abs(f-i)<2*i&&s(u)}(Math.floor(h),Math.floor(f),n[2],l))){for(var p=l/7,d=!1,g=0;g=n){if(null!=e)return a=!0,Math.floor(Math.abs(e.x-t.x)-Math.abs(e.y-t.y))/2;e=t}}),0}var d=e.height,g=e.width,v=Math.floor(3*d/(4*i));v_[2]&&(w+=x-_[2]-v,y=g-1)}_=[0,0,0,0,0],b=0}else _=[_[2],_[3],_[4],1,0],b=3;else _[++b]++;else _[b]++;s(_)&&h(_,w,g,!1)&&(v=_[0],a&&(m=f()))}var k=function(){var e=t.length;if(e<3)return null;if(e>3){var n=0,r=0;t.forEach(function(e){var t=e.estimatedModuleSize;n+=t,r+=t*t});var i=n/e,a=Math.sqrt(r/e-i*i);t.sort(function(e,t){var n=Math.abs(t.estimatedModuleSize-i),r=Math.abs(e.estimatedModuleSize-i);return n3;s++){var u=t[s];Math.abs(u.estimatedModuleSize-i)>o&&(t.splice(s,1),s--)}}return t.length>3&&(n=0,t.forEach(function(e){n+=e.estimatedModuleSize}),i=n/t.length,t.sort(function(e,t){if(t.count===e.count){var n=Math.abs(t.estimatedModuleSize-i),r=Math.abs(e.estimatedModuleSize-i);return n=i&&a>=o?(n=e[0],t=e[1],r=e[2]):o>=a&&o>=i?(n=e[1],t=e[0],r=e[2]):(n=e[2],t=e[0],r=e[1]),function(e,t,n){var r=t.x,i=t.y;return(n.x-r)*(e.y-i)-(n.y-i)*(e.x-r)}(t,n,r)<0){var s=t;t=r,r=s}return{bottomLeft:{x:t.x,y:t.y},topLeft:{x:n.x,y:n.y},topRight:{x:r.x,y:r.y}}}(k):null}},function(e,t,n){"use strict";var r=n(5),i=n(7),a=n(8),o=n(2),s=n(6);function u(e,t,n){for(var r=!0,i=0;ie||o<-1||o>t)throw new Error;r=!1,-1==a?(n[i]=0,r=!0):a==e&&(n[i]=e-1,r=!0),-1==o?(n[i+1]=0,r=!0):o==t&&(n[i+1]=t-1,r=!0)}r=!0;for(i=n.length-2;i>=0&&r;i-=2){a=Math.floor(n[i]),o=Math.floor(n[i+1]);if(a<-1||a>e||o<-1||o>t)throw new Error;r=!1,-1==a?(n[i]=0,r=!0):a==e&&(n[i]=e-1,r=!0),-1==o?(n[i+1]=0,r=!0):o==t&&(n[i+1]=t-1,r=!0)}return n}function l(e,t,n,r){return Math.sqrt((n-e)*(n-e)+(r-t)*(r-t))}function c(e,t,n,i,a){t=Math.floor(t),n=Math.floor(n);var o=Math.floor(i*e),s=Math.max(0,t-o),u=Math.min(a.width,t+o);if(u-s<3*e)return null;var l=Math.max(0,n-o),c=Math.min(a.height-1,n+o);return r.findAlignment(s,l,u-s,c-l,e,a)}function f(e,t,n,r,i){e=Math.floor(e),t=Math.floor(t),n=Math.floor(n),r=Math.floor(r);var a=Math.abs(r-t)>Math.abs(n-e);if(a){var o=e;e=t,t=o,o=n,n=r,r=o}for(var s=Math.abs(n-e),u=Math.abs(r-t),c=-s>>1,f=e0){if(v==r)break;v+=h,c-=s}}return 2==p?l(n+f,r,e,t):NaN}function h(e,t,n,r,i){var a=f(e,t,n,r,i),o=1,s=e-(n-e);s<0?(o=e/(e-s),s=0):s>=i.width&&(o=(i.width-1-e)/(s-e),s=i.width-1);var u=t-(r-t)*o;return o=1,u<0?(o=t/(t-u),u=0):u>=i.height&&(o=(i.height-1-t)/(u-t),u=i.height-1),(a+=f(e,t,s=e+(s-e)*o,u,i))-1}function p(e,t,n){var r=h(e.x,e.y,t.x,t.y,n),i=h(t.x,t.y,e.x,e.y,n);return s.isNaN(r)?i/7:s.isNaN(i)?r/7:(r+i)/14}t.extract=function(e,t){var n=function(e,t,n,r){return(p(e,t,r)+p(e,n,r))/2}(t.topLeft,t.topRight,t.bottomLeft,e);if(n<1)return null;var r=function(e,t,n,r){var i=7+(Math.round(l(e.x,e.y,t.x,t.y)/r)+Math.round(l(e.x,e.y,n.x,n.y)/r)>>1);switch(3&i){case 0:i++;break;case 2:i--}return i}(t.topLeft,t.topRight,t.bottomLeft,n);if(!r)return null;var s=function(e){if(e%4!=1)return null;var t=e-17>>2;return t<1||t>40?null:a.getVersionForNumber(t)}(r);if(null==s)return null;var f=s.getDimensionForVersion()-7,h=null;if(s.alignmentPatternCenters.length>0)for(var d=t.topRight.x-t.topLeft.x+t.bottomLeft.x,g=t.topRight.y-t.topLeft.y+t.bottomLeft.y,v=1-3/f,m=t.topLeft.x+v*(d-t.topLeft.x),_=t.topLeft.y+v*(g-t.topLeft.y),w=4;w<=16&&!(h=c(n,m,_,w,e));w<<=1);return function(e,t,n){if(t<=0)return null;for(var r=o.BitMatrix.createEmpty(t,t),a=new Array(t<<1),s=0;s>1),a[f+1]=c;a=i.transformPoints(n,a);try{var h=u(e.width,e.height,a)}catch(e){return null}for(f=0;f>1,s,e.get(Math.floor(h[f]),Math.floor(h[f+1])))}return r}(e,r,function(e,t,n,r,a){var o,s,u,l,c=a-3.5;return null!=r?(o=r.x,s=r.y,u=l=c-3):(o=t.x-e.x+n.x,s=t.y-e.y+n.y,u=l=c),i.quadrilateralToQuadrilateral(3.5,3.5,c,3.5,u,l,3.5,c,e.x,e.y,t.x,t.y,o,s,n.x,n.y)}(t.topLeft,t.topRight,t.bottomLeft,h,r))}},function(e,t,n){"use strict";var r=n(6);function i(e,t,n,r){if(Math.abs(n-e.y)<=t&&Math.abs(r-e.x)<=t){var i=Math.abs(t-e.estimatedModuleSize);return i<=1||i<=e.estimatedModuleSize}return!1}function a(e,t,n,r){return{x:(e.x+n)/2,y:(e.y+t)/2,estimatedModuleSize:(e.estimatedModuleSize+r)/2}}function o(e,t){for(var n=t/2,r=0;r<3;r++)if(Math.abs(t-e[r])>=n)return!1;return!0}function s(e,t){var n=t-e[2]-e[1]/2;return r.isNaN(n)?null:n}t.findAlignment=function(e,t,n,r,u,l){var c=[];function f(e,t,n,r){var u=e[0]+e[1]+e[2],f=s(e,n);if(null==f)return null;var h=function(e,t,n,r,i,a){for(var u=a.height,l=[0,0,0],c=e;c>=0&&a.get(t,c)&&l[1]<=n;)l[1]++,c--;if(c<0||l[1]>n)return null;for(;c>=0&&!a.get(t,c)&&l[0]<=n;)l[0]++,c--;if(l[0]>n)return null;for(c=e+1;cn)return null;for(;cn)return null;var f=l[0]+l[1]+l[2];return 5*Math.abs(f-r)>=2*r?null:o(l,i)?s(l,c):null}(t,Math.floor(f),2*e[1],u,r,l);if(null!=h){var p=(e[0]+e[1]+e[2])/3;for(var d in c){var g=c[d];if(i(g,p,h,f))return a(g,h,f,p)}var v={x:f,y:h,estimatedModuleSize:p};c.push(v)}return null}for(var h=e+n,p=t+(r>>1),d=[0,0,0],g=0;g>1:-(g+1>>1));d[0]=0,d[1]=0,d[2]=0;for(var m=e;m>4&15]+n[e>>8&15]+n[e>>12&15]+n[e>>16&15]+n[e>>20&15]+n[e>>24&15]+n[e>>28&15]},t.isNaN=function(e){return"[object Number]"===Object.prototype.toString.call(e)&&e!==+e}},function(e,t){"use strict";function n(e,t,n,r,i,a,o,s){var u=e-n+i-o,l=t-r+a-s;if(0==u&&0==l)return{a11:n-e,a21:i-n,a31:e,a12:r-t,a22:a-r,a32:t,a13:0,a23:0,a33:1};var c=n-i,f=o-i,h=r-a,p=s-a,d=c*p-f*h,g=(u*p-f*l)/d,v=(c*l-u*h)/d;return{a11:n-e+g*n,a21:o-e+v*o,a31:e,a12:r-t+g*r,a22:s-t+v*s,a32:t,a13:g,a23:v,a33:1}}t.transformPoints=function(e,t){for(var n=t.length,r=e.a11,i=e.a12,a=e.a13,o=e.a21,s=e.a22,u=e.a23,l=e.a31,c=e.a32,f=e.a33,h=0;h40)throw new Error("Invalid version number "+e);return u[e-1]}t.getVersionForNumber=l},function(e,t,n){"use strict";var r=n(2),i=n(10),a=n(6),o=n(12),s=n(8),u=21522,l=[[21522,0],[20773,1],[24188,2],[23371,3],[17913,4],[16590,5],[20375,6],[19104,7],[30660,8],[29427,9],[32170,10],[30877,11],[26159,12],[25368,13],[27713,14],[26998,15],[5769,16],[5054,17],[7399,18],[6608,19],[1890,20],[597,21],[3340,22],[2107,23],[13663,24],[12392,25],[16177,26],[14854,27],[9396,28],[8579,29],[11994,30],[11245,31]],c=[function(e,t){return 0==(e+t&1)},function(e,t){return 0==(1&e)},function(e,t){return t%3==0},function(e,t){return(e+t)%3==0},function(e,t){return 0==((e>>1)+t/3&1)},function(e,t){return(e*t&1)+e*t%3==0},function(e,t){return 0==((e*t&1)+e*t%3&1)},function(e,t){return 0==((e+t&1)+e*t%3&1)}],f=[{ordinal:1,bits:0,name:"M"},{ordinal:0,bits:1,name:"L"},{ordinal:3,bits:2,name:"H"},{ordinal:2,bits:3,name:"Q"}];function h(e,t,n){for(var i=c[n.dataMask],a=e.height,o=function(e){for(var t=e.getDimensionForVersion(),n=new Array(t*t),i=0;i6&&(a.setRegion(t-11,0,3,6),a.setRegion(0,t-11,6,3)),a}(t),s=!0,u=[],l=0,f=0,h=0,p=a-1;p>0;p-=2){6==p&&p--;for(var d=0;d>3&3],dataMask:7&e}}function d(e,t){for(var n=1/0,r=0,i=0;i=0;r--)t=e.copyBit(8,r,t);var i=e.height,a=0,o=i-7;for(r=i-1;r>=o;r--)a=e.copyBit(8,r,a);for(n=i-8;n>2;if(n<=6)return s.getVersionForNumber(n);for(var r=0,i=t-11,a=5;a>=0;a--)for(var o=t-9;o>=i;o--)r=e.copyBit(o,a,r);var u=s.Version.decodeVersionInformation(r);if(null!=u&&u.getDimensionForVersion()==t)return u;for(r=0,o=5;o>=0;o--)for(a=t-9;a>=i;a--)r=e.copyBit(o,a,r);return null!=(u=s.Version.decodeVersionInformation(r))&&u.getDimensionForVersion()==t?u:null}(e);if(!t)return null;var n=g(e);if(!n)return null;var r=n.errorCorrectionLevel,a=h(e,t,n);if(!a)return null;var o=function(e,t,n){if(e.length!=t.totalCodewords)throw new Error("Invalid number of codewords for version; got "+e.length+" expected "+t.totalCodewords);var r=t.getECBlocksForLevel(n),i=0,a=r.ecBlocks;a.forEach(function(e){i+=e.count});var o=new Array(i),s=0;a.forEach(function(e){for(var t=0;t=0&&o[l].codewords.length!=u;)l--;l++;for(var c=u-r.ecCodewordsPerBlock,f=0,h=0;h=t.length)throw new Error("Could not decode alphanumeric char");return t[e].charCodeAt(0)}var a=function(){function e(e,t){this.characterCountBitsForVersions=e,this.bits=t}return e.prototype.getCharacterCountBits=function(e){if(null==this.characterCountBitsForVersions)throw new Error("Character count doesn't apply to this mode");var t;return t=e<=9?0:e<=26?1:2,this.characterCountBitsForVersions[t]},e}(),o=new a([0,0,0],0),s=new a([10,12,14],1),u=new a([9,11,13],2),l=new a([0,0,0],3),c=new a([8,16,16],4),f=new a(null,7),h=new a([8,10,12],8),p=new a(null,5),d=new a(null,9),g=new a([8,10,12],13);function v(e){switch(e){case 0:return o;case 1:return s;case 2:return u;case 3:return l;case 4:return c;case 5:return p;case 7:return f;case 8:return h;case 9:return d;case 13:return g;default:throw new Error("Couldn't decode mode from byte array")}}function m(e){var t=e.readBits(8);if(0==(128&t))return 127&t;if(128==(192&t))return(63&t)<<8|e.readBits(8);if(192==(224&t))return(31&t)<<16|e.readBits(16);throw new Error("Bad ECI bits starting with byte "+t)}function _(e,t,n){if(13*n>e.available())return!1;for(var r=new Array(2*n),i=0;n>0;){var a=e.readBits(13),o=Math.floor(a/96)<<8|a%96;o+=o<959?41377:42657,r[i]=o>>8&255,r[i+1]=255&o,i+=2,n--}return t.val=r,!0}function w(e,t,n){for(;n>=3;){if(e.available()<10)return!1;var r=e.readBits(10);if(r>=1e3)return!1;t.val.push(i(Math.floor(r/100))),t.val.push(i(Math.floor(r/10)%10)),t.val.push(i(r%10)),n-=3}if(2==n){if(e.available()<7)return!1;var a=e.readBits(7);if(a>=100)return!1;t.val.push(i(Math.floor(a/10))),t.val.push(i(a%10))}else if(1==n){if(e.available()<4)return!1;var o=e.readBits(4);if(o>=10)return!1;t.val.push(i(o))}return!0}function b(e,t,n,r){for(var a=t.val.length;n>1;){if(e.available()<11)return!1;var o=e.readBits(11);t.val.push(i(Math.floor(o/45))),t.val.push(i(o%45)),n-=2}if(1==n){if(e.available()<6)return!1;t.val.push(i(e.readBits(6)))}if(r)for(var s=a;se.available())return!1;for(var r=new Array(n),i=0;i30)return null}else if(i==g){var A=a.readBits(4),M=a.readBits(i.getCharacterCountBits(t));if(A==x&&!_(a,k,M))return null}else{var T=a.readBits(i.getCharacterCountBits(t));if(i==s){if(!w(a,k,T))return null}else if(i==u){if(!b(a,k,T,E))return null}else if(i==c){if(!y(a,k,T))return null}else if(i!=h)return null}return k.val}},function(e,t){"use strict";var n=function(){function e(e){this.byteOffset=0,this.bitOffset=0,this.bytes=e}return e.prototype.readBits=function(e){if(e<1||e>32||e>this.available())throw new Error("Cannot read "+e.toString()+" bits");var t=0;if(this.bitOffset>0){var n=8-this.bitOffset,r=e>8-r<<(a=n-r);t=(this.bytes[this.byteOffset]&i)>>a,e-=r,this.bitOffset+=r,8==this.bitOffset&&(this.bitOffset=0,this.byteOffset++)}if(e>0){for(;e>=8;)t=t<<8|255&this.bytes[this.byteOffset],this.byteOffset++,e-=8;if(e>0){var a;i=255>>(a=8-e)<>a,this.bitOffset+=e}}return t},e.prototype.available=function(){return 8*(this.bytes.length-this.byteOffset)-this.bitOffset},e}();t.BitStream=n},function(e,t){"use strict";var n=function(){function e(){this.field=new i(285,256,0)}return e.prototype.decode=function(e,t){for(var n=new r(this.field,e),a=new Array(t),o=!0,s=0;s=n/2;){var u=i,l=o;if(o=s,(i=a).isZero())return null;a=u;for(var c=this.field.zero,f=i.getCoefficient(i.degree()),h=this.field.inverse(f);a.degree()>=i.degree()&&!a.isZero();){var p=a.degree()-i.degree(),d=this.field.multiply(a.getCoefficient(a.degree()),h);c=c.addOrSubtract(this.field.buildMonomial(p,d)),a=a.addOrSubtract(i.multiplyByMonomial(p,d))}if(s=c.multiplyPoly(o).addOrSubtract(l),a.degree()>=i.degree())return null}var g=s.getCoefficient(0);if(0==g)return null;var v=this.field.inverse(g);return[s.multiply(v),a.multiply(v)]},e.prototype.findErrorLocations=function(e){var t=e.degree();if(1==t)return[e.getCoefficient(1)];for(var n=new Array(t),r=0,i=1;i1&&0==t[0]){for(var r=1;rr.length){var a=n;n=r,r=a}for(var o=new Array(r.length),s=r.length-n.length,u=0;u=this.size&&(e^=this.primitive,e&=this.size-1);for(t=0;t>>1,F=[["ary",x],["bind",g],["bindKey",v],["curry",_],["curryRight",w],["flip",E],["partial",b],["partialRight",y],["rearg",k]],N="[object Arguments]",P="[object Array]",U="[object AsyncFunction]",q="[object Boolean]",V="[object Date]",Z="[object DOMException]",W="[object Error]",G="[object Function]",H="[object GeneratorFunction]",Y="[object Map]",$="[object Number]",X="[object Null]",J="[object Object]",K="[object Proxy]",Q="[object RegExp]",ee="[object Set]",te="[object String]",ne="[object Symbol]",re="[object Undefined]",ie="[object WeakMap]",ae="[object WeakSet]",oe="[object ArrayBuffer]",se="[object DataView]",ue="[object Float32Array]",le="[object Float64Array]",ce="[object Int8Array]",fe="[object Int16Array]",he="[object Int32Array]",pe="[object Uint8Array]",de="[object Uint8ClampedArray]",ge="[object Uint16Array]",ve="[object Uint32Array]",me=/\b__p \+= '';/g,_e=/\b(__p \+=) '' \+/g,we=/(__e\(.*?\)|\b__t\)) \+\n'';/g,be=/&(?:amp|lt|gt|quot|#39);/g,ye=/[&<>"']/g,xe=RegExp(be.source),ke=RegExp(ye.source),Ee=/<%-([\s\S]+?)%>/g,Se=/<%([\s\S]+?)%>/g,Ae=/<%=([\s\S]+?)%>/g,Me=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,Te=/^\w*$/,je=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,Ie=/[\\^$.*+?()[\]{}|]/g,Re=RegExp(Ie.source),Ce=/^\s+|\s+$/g,Be=/^\s+/,Le=/\s+$/,Oe=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,ze=/\{\n\/\* \[wrapped with (.+)\] \*/,De=/,? & /,Fe=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Ne=/\\(\\)?/g,Pe=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,Ue=/\w*$/,qe=/^[-+]0x[0-9a-f]+$/i,Ve=/^0b[01]+$/i,Ze=/^\[object .+?Constructor\]$/,We=/^0o[0-7]+$/i,Ge=/^(?:0|[1-9]\d*)$/,He=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,Ye=/($^)/,$e=/['\n\r\u2028\u2029\\]/g,Xe="\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff",Je="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",Ke="[\\ud800-\\udfff]",Qe="["+Je+"]",et="["+Xe+"]",tt="\\d+",nt="[\\u2700-\\u27bf]",rt="[a-z\\xdf-\\xf6\\xf8-\\xff]",it="[^\\ud800-\\udfff"+Je+tt+"\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde]",at="\\ud83c[\\udffb-\\udfff]",ot="[^\\ud800-\\udfff]",st="(?:\\ud83c[\\udde6-\\uddff]){2}",ut="[\\ud800-\\udbff][\\udc00-\\udfff]",lt="[A-Z\\xc0-\\xd6\\xd8-\\xde]",ct="(?:"+rt+"|"+it+")",ft="(?:"+lt+"|"+it+")",ht="(?:"+et+"|"+at+")"+"?",pt="[\\ufe0e\\ufe0f]?"+ht+("(?:\\u200d(?:"+[ot,st,ut].join("|")+")[\\ufe0e\\ufe0f]?"+ht+")*"),dt="(?:"+[nt,st,ut].join("|")+")"+pt,gt="(?:"+[ot+et+"?",et,st,ut,Ke].join("|")+")",vt=RegExp("['’]","g"),mt=RegExp(et,"g"),_t=RegExp(at+"(?="+at+")|"+gt+pt,"g"),wt=RegExp([lt+"?"+rt+"+(?:['’](?:d|ll|m|re|s|t|ve))?(?="+[Qe,lt,"$"].join("|")+")",ft+"+(?:['’](?:D|LL|M|RE|S|T|VE))?(?="+[Qe,lt+ct,"$"].join("|")+")",lt+"?"+ct+"+(?:['’](?:d|ll|m|re|s|t|ve))?",lt+"+(?:['’](?:D|LL|M|RE|S|T|VE))?","\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",tt,dt].join("|"),"g"),bt=RegExp("[\\u200d\\ud800-\\udfff"+Xe+"\\ufe0e\\ufe0f]"),yt=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,xt=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],kt=-1,Et={};Et[ue]=Et[le]=Et[ce]=Et[fe]=Et[he]=Et[pe]=Et[de]=Et[ge]=Et[ve]=!0,Et[N]=Et[P]=Et[oe]=Et[q]=Et[se]=Et[V]=Et[W]=Et[G]=Et[Y]=Et[$]=Et[J]=Et[Q]=Et[ee]=Et[te]=Et[ie]=!1;var St={};St[N]=St[P]=St[oe]=St[se]=St[q]=St[V]=St[ue]=St[le]=St[ce]=St[fe]=St[he]=St[Y]=St[$]=St[J]=St[Q]=St[ee]=St[te]=St[ne]=St[pe]=St[de]=St[ge]=St[ve]=!0,St[W]=St[G]=St[ie]=!1;var At={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Mt=parseFloat,Tt=parseInt,jt="object"==typeof e&&e&&e.Object===Object&&e,It="object"==typeof self&&self&&self.Object===Object&&self,Rt=jt||It||Function("return this")(),Ct="object"==typeof n&&n&&!n.nodeType&&n,Bt=Ct&&"object"==typeof t&&t&&!t.nodeType&&t,Lt=Bt&&Bt.exports===Ct,Ot=Lt&&jt.process,zt=function(){try{var e=Bt&&Bt.require&&Bt.require("util").types;return e||Ot&&Ot.binding&&Ot.binding("util")}catch(e){}}(),Dt=zt&&zt.isArrayBuffer,Ft=zt&&zt.isDate,Nt=zt&&zt.isMap,Pt=zt&&zt.isRegExp,Ut=zt&&zt.isSet,qt=zt&&zt.isTypedArray;function Vt(e,t,n){switch(n.length){case 0:return e.call(t);case 1:return e.call(t,n[0]);case 2:return e.call(t,n[0],n[1]);case 3:return e.call(t,n[0],n[1],n[2])}return e.apply(t,n)}function Zt(e,t,n,r){for(var i=-1,a=null==e?0:e.length;++i-1}function Xt(e,t,n){for(var r=-1,i=null==e?0:e.length;++r-1;);return n}function wn(e,t){for(var n=e.length;n--&&on(t,e[n],0)>-1;);return n}var bn=fn({"À":"A","Á":"A","Â":"A","Ã":"A","Ä":"A","Å":"A","à":"a","á":"a","â":"a","ã":"a","ä":"a","å":"a","Ç":"C","ç":"c","Ð":"D","ð":"d","È":"E","É":"E","Ê":"E","Ë":"E","è":"e","é":"e","ê":"e","ë":"e","Ì":"I","Í":"I","Î":"I","Ï":"I","ì":"i","í":"i","î":"i","ï":"i","Ñ":"N","ñ":"n","Ò":"O","Ó":"O","Ô":"O","Õ":"O","Ö":"O","Ø":"O","ò":"o","ó":"o","ô":"o","õ":"o","ö":"o","ø":"o","Ù":"U","Ú":"U","Û":"U","Ü":"U","ù":"u","ú":"u","û":"u","ü":"u","Ý":"Y","ý":"y","ÿ":"y","Æ":"Ae","æ":"ae","Þ":"Th","þ":"th","ß":"ss","Ā":"A","Ă":"A","Ą":"A","ā":"a","ă":"a","ą":"a","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","ć":"c","ĉ":"c","ċ":"c","č":"c","Ď":"D","Đ":"D","ď":"d","đ":"d","Ē":"E","Ĕ":"E","Ė":"E","Ę":"E","Ě":"E","ē":"e","ĕ":"e","ė":"e","ę":"e","ě":"e","Ĝ":"G","Ğ":"G","Ġ":"G","Ģ":"G","ĝ":"g","ğ":"g","ġ":"g","ģ":"g","Ĥ":"H","Ħ":"H","ĥ":"h","ħ":"h","Ĩ":"I","Ī":"I","Ĭ":"I","Į":"I","İ":"I","ĩ":"i","ī":"i","ĭ":"i","į":"i","ı":"i","Ĵ":"J","ĵ":"j","Ķ":"K","ķ":"k","ĸ":"k","Ĺ":"L","Ļ":"L","Ľ":"L","Ŀ":"L","Ł":"L","ĺ":"l","ļ":"l","ľ":"l","ŀ":"l","ł":"l","Ń":"N","Ņ":"N","Ň":"N","Ŋ":"N","ń":"n","ņ":"n","ň":"n","ŋ":"n","Ō":"O","Ŏ":"O","Ő":"O","ō":"o","ŏ":"o","ő":"o","Ŕ":"R","Ŗ":"R","Ř":"R","ŕ":"r","ŗ":"r","ř":"r","Ś":"S","Ŝ":"S","Ş":"S","Š":"S","ś":"s","ŝ":"s","ş":"s","š":"s","Ţ":"T","Ť":"T","Ŧ":"T","ţ":"t","ť":"t","ŧ":"t","Ũ":"U","Ū":"U","Ŭ":"U","Ů":"U","Ű":"U","Ų":"U","ũ":"u","ū":"u","ŭ":"u","ů":"u","ű":"u","ų":"u","Ŵ":"W","ŵ":"w","Ŷ":"Y","ŷ":"y","Ÿ":"Y","Ź":"Z","Ż":"Z","Ž":"Z","ź":"z","ż":"z","ž":"z","IJ":"IJ","ij":"ij","Œ":"Oe","œ":"oe","ʼn":"'n","ſ":"s"}),yn=fn({"&":"&","<":"<",">":">",'"':""","'":"'"});function xn(e){return"\\"+At[e]}function kn(e){return bt.test(e)}function En(e){var t=-1,n=Array(e.size);return e.forEach(function(e,r){n[++t]=[r,e]}),n}function Sn(e,t){return function(n){return e(t(n))}}function An(e,t){for(var n=-1,r=e.length,i=0,a=[];++n",""":'"',"'":"'"});var Cn=function e(t){var n,Xe=(t=null==t?Rt:Cn.defaults(Rt.Object(),t,Cn.pick(Rt,xt))).Array,Je=t.Date,Ke=t.Error,Qe=t.Function,et=t.Math,tt=t.Object,nt=t.RegExp,rt=t.String,it=t.TypeError,at=Xe.prototype,ot=Qe.prototype,st=tt.prototype,ut=t["__core-js_shared__"],lt=ot.toString,ct=st.hasOwnProperty,ft=0,ht=(n=/[^.]+$/.exec(ut&&ut.keys&&ut.keys.IE_PROTO||""))?"Symbol(src)_1."+n:"",pt=st.toString,dt=lt.call(tt),gt=Rt._,_t=nt("^"+lt.call(ct).replace(Ie,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),bt=Lt?t.Buffer:r,At=t.Symbol,jt=t.Uint8Array,It=bt?bt.allocUnsafe:r,Ct=Sn(tt.getPrototypeOf,tt),Bt=tt.create,Ot=st.propertyIsEnumerable,zt=at.splice,nn=At?At.isConcatSpreadable:r,fn=At?At.iterator:r,Bn=At?At.toStringTag:r,Ln=function(){try{var e=Fa(tt,"defineProperty");return e({},"",{}),e}catch(e){}}(),On=t.clearTimeout!==Rt.clearTimeout&&t.clearTimeout,zn=Je&&Je.now!==Rt.Date.now&&Je.now,Dn=t.setTimeout!==Rt.setTimeout&&t.setTimeout,Fn=et.ceil,Nn=et.floor,Pn=tt.getOwnPropertySymbols,Un=bt?bt.isBuffer:r,qn=t.isFinite,Vn=at.join,Zn=Sn(tt.keys,tt),Wn=et.max,Gn=et.min,Hn=Je.now,Yn=t.parseInt,$n=et.random,Xn=at.reverse,Jn=Fa(t,"DataView"),Kn=Fa(t,"Map"),Qn=Fa(t,"Promise"),er=Fa(t,"Set"),tr=Fa(t,"WeakMap"),nr=Fa(tt,"create"),rr=tr&&new tr,ir={},ar=co(Jn),or=co(Kn),sr=co(Qn),ur=co(er),lr=co(tr),cr=At?At.prototype:r,fr=cr?cr.valueOf:r,hr=cr?cr.toString:r;function pr(e){if(Ts(e)&&!ms(e)&&!(e instanceof mr)){if(e instanceof vr)return e;if(ct.call(e,"__wrapped__"))return fo(e)}return new vr(e)}var dr=function(){function e(){}return function(t){if(!Ms(t))return{};if(Bt)return Bt(t);e.prototype=t;var n=new e;return e.prototype=r,n}}();function gr(){}function vr(e,t){this.__wrapped__=e,this.__actions__=[],this.__chain__=!!t,this.__index__=0,this.__values__=r}function mr(e){this.__wrapped__=e,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=O,this.__views__=[]}function _r(e){var t=-1,n=null==e?0:e.length;for(this.clear();++t=t?e:t)),e}function Or(e,t,n,i,a,o){var s,u=t&c,l=t&f,p=t&h;if(n&&(s=a?n(e,i,a,o):n(e)),s!==r)return s;if(!Ms(e))return e;var d=ms(e);if(d){if(s=function(e){var t=e.length,n=new e.constructor(t);return t&&"string"==typeof e[0]&&ct.call(e,"index")&&(n.index=e.index,n.input=e.input),n}(e),!u)return na(e,s)}else{var g=Ua(e),v=g==G||g==H;if(ys(e))return Xi(e,u);if(g==J||g==N||v&&!a){if(s=l||v?{}:Va(e),!u)return l?function(e,t){return ra(e,Pa(e),t)}(e,function(e,t){return e&&ra(t,au(t),e)}(s,e)):function(e,t){return ra(e,Na(e),t)}(e,Rr(s,e))}else{if(!St[g])return a?e:{};s=function(e,t,n){var r,i,a,o=e.constructor;switch(t){case oe:return Ji(e);case q:case V:return new o(+e);case se:return function(e,t){var n=t?Ji(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.byteLength)}(e,n);case ue:case le:case ce:case fe:case he:case pe:case de:case ge:case ve:return Ki(e,n);case Y:return new o;case $:case te:return new o(e);case Q:return(a=new(i=e).constructor(i.source,Ue.exec(i))).lastIndex=i.lastIndex,a;case ee:return new o;case ne:return r=e,fr?tt(fr.call(r)):{}}}(e,g,u)}}o||(o=new xr);var m=o.get(e);if(m)return m;if(o.set(e,s),Bs(e))return e.forEach(function(r){s.add(Or(r,t,n,r,e,o))}),s;if(js(e))return e.forEach(function(r,i){s.set(i,Or(r,t,n,i,e,o))}),s;var _=d?r:(p?l?Ra:Ia:l?au:iu)(e);return Wt(_||e,function(r,i){_&&(r=e[i=r]),Tr(s,i,Or(r,t,n,i,e,o))}),s}function zr(e,t,n){var i=n.length;if(null==e)return!i;for(e=tt(e);i--;){var a=n[i],o=t[a],s=e[a];if(s===r&&!(a in e)||!o(s))return!1}return!0}function Dr(e,t,n){if("function"!=typeof e)throw new it(o);return ro(function(){e.apply(r,n)},t)}function Fr(e,t,n,r){var a=-1,o=$t,s=!0,u=e.length,l=[],c=t.length;if(!u)return l;n&&(t=Jt(t,gn(n))),r?(o=Xt,s=!1):t.length>=i&&(o=mn,s=!1,t=new yr(t));e:for(;++a-1},wr.prototype.set=function(e,t){var n=this.__data__,r=jr(n,e);return r<0?(++this.size,n.push([e,t])):n[r][1]=t,this},br.prototype.clear=function(){this.size=0,this.__data__={hash:new _r,map:new(Kn||wr),string:new _r}},br.prototype.delete=function(e){var t=za(this,e).delete(e);return this.size-=t?1:0,t},br.prototype.get=function(e){return za(this,e).get(e)},br.prototype.has=function(e){return za(this,e).has(e)},br.prototype.set=function(e,t){var n=za(this,e),r=n.size;return n.set(e,t),this.size+=n.size==r?0:1,this},yr.prototype.add=yr.prototype.push=function(e){return this.__data__.set(e,s),this},yr.prototype.has=function(e){return this.__data__.has(e)},xr.prototype.clear=function(){this.__data__=new wr,this.size=0},xr.prototype.delete=function(e){var t=this.__data__,n=t.delete(e);return this.size=t.size,n},xr.prototype.get=function(e){return this.__data__.get(e)},xr.prototype.has=function(e){return this.__data__.has(e)},xr.prototype.set=function(e,t){var n=this.__data__;if(n instanceof wr){var r=n.__data__;if(!Kn||r.length0&&n(s)?t>1?Zr(s,t-1,n,r,i):Kt(i,s):r||(i[i.length]=s)}return i}var Wr=sa(),Gr=sa(!0);function Hr(e,t){return e&&Wr(e,t,iu)}function Yr(e,t){return e&&Gr(e,t,iu)}function $r(e,t){return Yt(t,function(t){return Es(e[t])})}function Xr(e,t){for(var n=0,i=(t=Gi(t,e)).length;null!=e&&nt}function ei(e,t){return null!=e&&ct.call(e,t)}function ti(e,t){return null!=e&&t in tt(e)}function ni(e,t,n){for(var i=n?Xt:$t,a=e[0].length,o=e.length,s=o,u=Xe(o),l=1/0,c=[];s--;){var f=e[s];s&&t&&(f=Jt(f,gn(t))),l=Gn(f.length,l),u[s]=!n&&(t||a>=120&&f.length>=120)?new yr(s&&f):r}f=e[0];var h=-1,p=u[0];e:for(;++h=s)return u;var l=n[r];return u*("desc"==l?-1:1)}}return e.index-t.index}(e,t,n)})}function _i(e,t,n){for(var r=-1,i=t.length,a={};++r-1;)s!==e&&zt.call(s,u,1),zt.call(e,u,1);return e}function bi(e,t){for(var n=e?t.length:0,r=n-1;n--;){var i=t[n];if(n==r||i!==a){var a=i;Wa(i)?zt.call(e,i,1):Fi(e,i)}}return e}function yi(e,t){return e+Nn($n()*(t-e+1))}function xi(e,t){var n="";if(!e||t<1||t>C)return n;do{t%2&&(n+=e),(t=Nn(t/2))&&(e+=e)}while(t);return n}function ki(e,t){return io(Qa(e,t,Iu),e+"")}function Ei(e){return Er(pu(e))}function Si(e,t){var n=pu(e);return so(n,Lr(t,0,n.length))}function Ai(e,t,n,i){if(!Ms(e))return e;for(var a=-1,o=(t=Gi(t,e)).length,s=o-1,u=e;null!=u&&++ai?0:i+t),(n=n>i?i:n)<0&&(n+=i),i=t>n?0:n-t>>>0,t>>>=0;for(var a=Xe(i);++r>>1,o=e[a];null!==o&&!Os(o)&&(n?o<=t:o=i){var c=t?null:xa(e);if(c)return Mn(c);s=!1,a=mn,l=new yr}else l=t?[]:u;e:for(;++r=i?e:Ii(e,t,n)}var $i=On||function(e){return Rt.clearTimeout(e)};function Xi(e,t){if(t)return e.slice();var n=e.length,r=It?It(n):new e.constructor(n);return e.copy(r),r}function Ji(e){var t=new e.constructor(e.byteLength);return new jt(t).set(new jt(e)),t}function Ki(e,t){var n=t?Ji(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.length)}function Qi(e,t){if(e!==t){var n=e!==r,i=null===e,a=e==e,o=Os(e),s=t!==r,u=null===t,l=t==t,c=Os(t);if(!u&&!c&&!o&&e>t||o&&s&&l&&!u&&!c||i&&s&&l||!n&&l||!a)return 1;if(!i&&!o&&!c&&e1?n[a-1]:r,s=a>2?n[2]:r;for(o=e.length>3&&"function"==typeof o?(a--,o):r,s&&Ga(n[0],n[1],s)&&(o=a<3?r:o,a=1),t=tt(t);++i-1?a[o?t[s]:s]:r}}function ha(e){return ja(function(t){var n=t.length,i=n,a=vr.prototype.thru;for(e&&t.reverse();i--;){var s=t[i];if("function"!=typeof s)throw new it(o);if(a&&!u&&"wrapper"==Ba(s))var u=new vr([],!0)}for(i=u?i:n;++i1&&_.reverse(),f&&lu))return!1;var c=o.get(e);if(c&&o.get(t))return c==t;var f=-1,h=!0,g=n&d?new yr:r;for(o.set(e,t),o.set(t,e);++f-1&&e%1==0&&e1?"& ":"")+t[r],t=t.join(n>2?", ":" "),e.replace(Oe,"{\n/* [wrapped with "+t+"] */\n")}(r,function(e,t){return Wt(F,function(n){var r="_."+n[0];t&n[1]&&!$t(e,r)&&e.push(r)}),e.sort()}(function(e){var t=e.match(ze);return t?t[1].split(De):[]}(r),n)))}function oo(e){var t=0,n=0;return function(){var i=Hn(),a=T-(i-n);if(n=i,a>0){if(++t>=M)return arguments[0]}else t=0;return e.apply(r,arguments)}}function so(e,t){var n=-1,i=e.length,a=i-1;for(t=t===r?i:t;++n1?e[t-1]:r;return Co(e,n="function"==typeof n?(e.pop(),n):r)});function No(e){var t=pr(e);return t.__chain__=!0,t}function Po(e,t){return t(e)}var Uo=ja(function(e){var t=e.length,n=t?e[0]:0,i=this.__wrapped__,a=function(t){return Br(t,e)};return!(t>1||this.__actions__.length)&&i instanceof mr&&Wa(n)?((i=i.slice(n,+n+(t?1:0))).__actions__.push({func:Po,args:[a],thisArg:r}),new vr(i,this.__chain__).thru(function(e){return t&&!e.length&&e.push(r),e})):this.thru(a)});var qo=ia(function(e,t,n){ct.call(e,n)?++e[n]:Cr(e,n,1)});var Vo=fa(vo),Zo=fa(mo);function Wo(e,t){return(ms(e)?Wt:Nr)(e,Oa(t,3))}function Go(e,t){return(ms(e)?Gt:Pr)(e,Oa(t,3))}var Ho=ia(function(e,t,n){ct.call(e,n)?e[n].push(t):Cr(e,n,[t])});var Yo=ki(function(e,t,n){var r=-1,i="function"==typeof t,a=ws(e)?Xe(e.length):[];return Nr(e,function(e){a[++r]=i?Vt(t,e,n):ri(e,t,n)}),a}),$o=ia(function(e,t,n){Cr(e,n,t)});function Xo(e,t){return(ms(e)?Jt:hi)(e,Oa(t,3))}var Jo=ia(function(e,t,n){e[n?0:1].push(t)},function(){return[[],[]]});var Ko=ki(function(e,t){if(null==e)return[];var n=t.length;return n>1&&Ga(e,t[0],t[1])?t=[]:n>2&&Ga(t[0],t[1],t[2])&&(t=[t[0]]),mi(e,Zr(t,1),[])}),Qo=zn||function(){return Rt.Date.now()};function es(e,t,n){return t=n?r:t,t=e&&null==t?e.length:t,Ea(e,x,r,r,r,r,t)}function ts(e,t){var n;if("function"!=typeof t)throw new it(o);return e=Us(e),function(){return--e>0&&(n=t.apply(this,arguments)),e<=1&&(t=r),n}}var ns=ki(function(e,t,n){var r=g;if(n.length){var i=An(n,La(ns));r|=b}return Ea(e,r,t,n,i)}),rs=ki(function(e,t,n){var r=g|v;if(n.length){var i=An(n,La(rs));r|=b}return Ea(t,r,e,n,i)});function is(e,t,n){var i,a,s,u,l,c,f=0,h=!1,p=!1,d=!0;if("function"!=typeof e)throw new it(o);function g(t){var n=i,o=a;return i=a=r,f=t,u=e.apply(o,n)}function v(e){var n=e-c;return c===r||n>=t||n<0||p&&e-f>=s}function m(){var e=Qo();if(v(e))return _(e);l=ro(m,function(e){var n=t-(e-c);return p?Gn(n,s-(e-f)):n}(e))}function _(e){return l=r,d&&i?g(e):(i=a=r,u)}function w(){var e=Qo(),n=v(e);if(i=arguments,a=this,c=e,n){if(l===r)return function(e){return f=e,l=ro(m,t),h?g(e):u}(c);if(p)return l=ro(m,t),g(c)}return l===r&&(l=ro(m,t)),u}return t=Vs(t)||0,Ms(n)&&(h=!!n.leading,s=(p="maxWait"in n)?Wn(Vs(n.maxWait)||0,t):s,d="trailing"in n?!!n.trailing:d),w.cancel=function(){l!==r&&$i(l),f=0,i=c=a=l=r},w.flush=function(){return l===r?u:_(Qo())},w}var as=ki(function(e,t){return Dr(e,1,t)}),os=ki(function(e,t,n){return Dr(e,Vs(t)||0,n)});function ss(e,t){if("function"!=typeof e||null!=t&&"function"!=typeof t)throw new it(o);var n=function(){var r=arguments,i=t?t.apply(this,r):r[0],a=n.cache;if(a.has(i))return a.get(i);var o=e.apply(this,r);return n.cache=a.set(i,o)||a,o};return n.cache=new(ss.Cache||br),n}function us(e){if("function"!=typeof e)throw new it(o);return function(){var t=arguments;switch(t.length){case 0:return!e.call(this);case 1:return!e.call(this,t[0]);case 2:return!e.call(this,t[0],t[1]);case 3:return!e.call(this,t[0],t[1],t[2])}return!e.apply(this,t)}}ss.Cache=br;var ls=Hi(function(e,t){var n=(t=1==t.length&&ms(t[0])?Jt(t[0],gn(Oa())):Jt(Zr(t,1),gn(Oa()))).length;return ki(function(r){for(var i=-1,a=Gn(r.length,n);++i=t}),vs=ii(function(){return arguments}())?ii:function(e){return Ts(e)&&ct.call(e,"callee")&&!Ot.call(e,"callee")},ms=Xe.isArray,_s=Dt?gn(Dt):function(e){return Ts(e)&&Kr(e)==oe};function ws(e){return null!=e&&As(e.length)&&!Es(e)}function bs(e){return Ts(e)&&ws(e)}var ys=Un||Vu,xs=Ft?gn(Ft):function(e){return Ts(e)&&Kr(e)==V};function ks(e){if(!Ts(e))return!1;var t=Kr(e);return t==W||t==Z||"string"==typeof e.message&&"string"==typeof e.name&&!Rs(e)}function Es(e){if(!Ms(e))return!1;var t=Kr(e);return t==G||t==H||t==U||t==K}function Ss(e){return"number"==typeof e&&e==Us(e)}function As(e){return"number"==typeof e&&e>-1&&e%1==0&&e<=C}function Ms(e){var t=typeof e;return null!=e&&("object"==t||"function"==t)}function Ts(e){return null!=e&&"object"==typeof e}var js=Nt?gn(Nt):function(e){return Ts(e)&&Ua(e)==Y};function Is(e){return"number"==typeof e||Ts(e)&&Kr(e)==$}function Rs(e){if(!Ts(e)||Kr(e)!=J)return!1;var t=Ct(e);if(null===t)return!0;var n=ct.call(t,"constructor")&&t.constructor;return"function"==typeof n&&n instanceof n&<.call(n)==dt}var Cs=Pt?gn(Pt):function(e){return Ts(e)&&Kr(e)==Q};var Bs=Ut?gn(Ut):function(e){return Ts(e)&&Ua(e)==ee};function Ls(e){return"string"==typeof e||!ms(e)&&Ts(e)&&Kr(e)==te}function Os(e){return"symbol"==typeof e||Ts(e)&&Kr(e)==ne}var zs=qt?gn(qt):function(e){return Ts(e)&&As(e.length)&&!!Et[Kr(e)]};var Ds=wa(fi),Fs=wa(function(e,t){return e<=t});function Ns(e){if(!e)return[];if(ws(e))return Ls(e)?In(e):na(e);if(fn&&e[fn])return function(e){for(var t,n=[];!(t=e.next()).done;)n.push(t.value);return n}(e[fn]());var t=Ua(e);return(t==Y?En:t==ee?Mn:pu)(e)}function Ps(e){return e?(e=Vs(e))===R||e===-R?(e<0?-1:1)*B:e==e?e:0:0===e?e:0}function Us(e){var t=Ps(e),n=t%1;return t==t?n?t-n:t:0}function qs(e){return e?Lr(Us(e),0,O):0}function Vs(e){if("number"==typeof e)return e;if(Os(e))return L;if(Ms(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=Ms(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(Ce,"");var n=Ve.test(e);return n||We.test(e)?Tt(e.slice(2),n?2:8):qe.test(e)?L:+e}function Zs(e){return ra(e,au(e))}function Ws(e){return null==e?"":zi(e)}var Gs=aa(function(e,t){if(Xa(t)||ws(t))ra(t,iu(t),e);else for(var n in t)ct.call(t,n)&&Tr(e,n,t[n])}),Hs=aa(function(e,t){ra(t,au(t),e)}),Ys=aa(function(e,t,n,r){ra(t,au(t),e,r)}),$s=aa(function(e,t,n,r){ra(t,iu(t),e,r)}),Xs=ja(Br);var Js=ki(function(e,t){e=tt(e);var n=-1,i=t.length,a=i>2?t[2]:r;for(a&&Ga(t[0],t[1],a)&&(i=1);++n1),t}),ra(e,Ra(e),n),r&&(n=Or(n,c|f|h,Ma));for(var i=t.length;i--;)Fi(n,t[i]);return n});var lu=ja(function(e,t){return null==e?{}:function(e,t){return _i(e,t,function(t,n){return eu(e,n)})}(e,t)});function cu(e,t){if(null==e)return{};var n=Jt(Ra(e),function(e){return[e]});return t=Oa(t),_i(e,n,function(e,n){return t(e,n[0])})}var fu=ka(iu),hu=ka(au);function pu(e){return null==e?[]:vn(e,iu(e))}var du=la(function(e,t,n){return t=t.toLowerCase(),e+(n?gu(t):t)});function gu(e){return ku(Ws(e).toLowerCase())}function vu(e){return(e=Ws(e))&&e.replace(He,bn).replace(mt,"")}var mu=la(function(e,t,n){return e+(n?"-":"")+t.toLowerCase()}),_u=la(function(e,t,n){return e+(n?" ":"")+t.toLowerCase()}),wu=ua("toLowerCase");var bu=la(function(e,t,n){return e+(n?"_":"")+t.toLowerCase()});var yu=la(function(e,t,n){return e+(n?" ":"")+ku(t)});var xu=la(function(e,t,n){return e+(n?" ":"")+t.toUpperCase()}),ku=ua("toUpperCase");function Eu(e,t,n){return e=Ws(e),(t=n?r:t)===r?function(e){return yt.test(e)}(e)?function(e){return e.match(wt)||[]}(e):function(e){return e.match(Fe)||[]}(e):e.match(t)||[]}var Su=ki(function(e,t){try{return Vt(e,r,t)}catch(e){return ks(e)?e:new Ke(e)}}),Au=ja(function(e,t){return Wt(t,function(t){t=lo(t),Cr(e,t,ns(e[t],e))}),e});function Mu(e){return function(){return e}}var Tu=ha(),ju=ha(!0);function Iu(e){return e}function Ru(e){return ui("function"==typeof e?e:Or(e,c))}var Cu=ki(function(e,t){return function(n){return ri(n,e,t)}}),Bu=ki(function(e,t){return function(n){return ri(e,n,t)}});function Lu(e,t,n){var r=iu(t),i=$r(t,r);null!=n||Ms(t)&&(i.length||!r.length)||(n=t,t=e,e=this,i=$r(t,iu(t)));var a=!(Ms(n)&&"chain"in n&&!n.chain),o=Es(e);return Wt(i,function(n){var r=t[n];e[n]=r,o&&(e.prototype[n]=function(){var t=this.__chain__;if(a||t){var n=e(this.__wrapped__);return(n.__actions__=na(this.__actions__)).push({func:r,args:arguments,thisArg:e}),n.__chain__=t,n}return r.apply(e,Kt([this.value()],arguments))})}),e}function Ou(){}var zu=va(Jt),Du=va(Ht),Fu=va(tn);function Nu(e){return Ha(e)?cn(lo(e)):function(e){return function(t){return Xr(t,e)}}(e)}var Pu=_a(),Uu=_a(!0);function qu(){return[]}function Vu(){return!1}var Zu=ga(function(e,t){return e+t},0),Wu=ya("ceil"),Gu=ga(function(e,t){return e/t},1),Hu=ya("floor");var Yu,$u=ga(function(e,t){return e*t},1),Xu=ya("round"),Ju=ga(function(e,t){return e-t},0);return pr.after=function(e,t){if("function"!=typeof t)throw new it(o);return e=Us(e),function(){if(--e<1)return t.apply(this,arguments)}},pr.ary=es,pr.assign=Gs,pr.assignIn=Hs,pr.assignInWith=Ys,pr.assignWith=$s,pr.at=Xs,pr.before=ts,pr.bind=ns,pr.bindAll=Au,pr.bindKey=rs,pr.castArray=function(){if(!arguments.length)return[];var e=arguments[0];return ms(e)?e:[e]},pr.chain=No,pr.chunk=function(e,t,n){t=(n?Ga(e,t,n):t===r)?1:Wn(Us(t),0);var i=null==e?0:e.length;if(!i||t<1)return[];for(var a=0,o=0,s=Xe(Fn(i/t));aa?0:a+n),(i=i===r||i>a?a:Us(i))<0&&(i+=a),i=n>i?0:qs(i);n>>0)?(e=Ws(e))&&("string"==typeof t||null!=t&&!Cs(t))&&!(t=zi(t))&&kn(e)?Yi(In(e),0,n):e.split(t,n):[]},pr.spread=function(e,t){if("function"!=typeof e)throw new it(o);return t=null==t?0:Wn(Us(t),0),ki(function(n){var r=n[t],i=Yi(n,0,t);return r&&Kt(i,r),Vt(e,this,i)})},pr.tail=function(e){var t=null==e?0:e.length;return t?Ii(e,1,t):[]},pr.take=function(e,t,n){return e&&e.length?Ii(e,0,(t=n||t===r?1:Us(t))<0?0:t):[]},pr.takeRight=function(e,t,n){var i=null==e?0:e.length;return i?Ii(e,(t=i-(t=n||t===r?1:Us(t)))<0?0:t,i):[]},pr.takeRightWhile=function(e,t){return e&&e.length?Pi(e,Oa(t,3),!1,!0):[]},pr.takeWhile=function(e,t){return e&&e.length?Pi(e,Oa(t,3)):[]},pr.tap=function(e,t){return t(e),e},pr.throttle=function(e,t,n){var r=!0,i=!0;if("function"!=typeof e)throw new it(o);return Ms(n)&&(r="leading"in n?!!n.leading:r,i="trailing"in n?!!n.trailing:i),is(e,t,{leading:r,maxWait:t,trailing:i})},pr.thru=Po,pr.toArray=Ns,pr.toPairs=fu,pr.toPairsIn=hu,pr.toPath=function(e){return ms(e)?Jt(e,lo):Os(e)?[e]:na(uo(Ws(e)))},pr.toPlainObject=Zs,pr.transform=function(e,t,n){var r=ms(e),i=r||ys(e)||zs(e);if(t=Oa(t,4),null==n){var a=e&&e.constructor;n=i?r?new a:[]:Ms(e)&&Es(a)?dr(Ct(e)):{}}return(i?Wt:Hr)(e,function(e,r,i){return t(n,e,r,i)}),n},pr.unary=function(e){return es(e,1)},pr.union=To,pr.unionBy=jo,pr.unionWith=Io,pr.uniq=function(e){return e&&e.length?Di(e):[]},pr.uniqBy=function(e,t){return e&&e.length?Di(e,Oa(t,2)):[]},pr.uniqWith=function(e,t){return t="function"==typeof t?t:r,e&&e.length?Di(e,r,t):[]},pr.unset=function(e,t){return null==e||Fi(e,t)},pr.unzip=Ro,pr.unzipWith=Co,pr.update=function(e,t,n){return null==e?e:Ni(e,t,Wi(n))},pr.updateWith=function(e,t,n,i){return i="function"==typeof i?i:r,null==e?e:Ni(e,t,Wi(n),i)},pr.values=pu,pr.valuesIn=function(e){return null==e?[]:vn(e,au(e))},pr.without=Bo,pr.words=Eu,pr.wrap=function(e,t){return cs(Wi(t),e)},pr.xor=Lo,pr.xorBy=Oo,pr.xorWith=zo,pr.zip=Do,pr.zipObject=function(e,t){return Vi(e||[],t||[],Tr)},pr.zipObjectDeep=function(e,t){return Vi(e||[],t||[],Ai)},pr.zipWith=Fo,pr.entries=fu,pr.entriesIn=hu,pr.extend=Hs,pr.extendWith=Ys,Lu(pr,pr),pr.add=Zu,pr.attempt=Su,pr.camelCase=du,pr.capitalize=gu,pr.ceil=Wu,pr.clamp=function(e,t,n){return n===r&&(n=t,t=r),n!==r&&(n=(n=Vs(n))==n?n:0),t!==r&&(t=(t=Vs(t))==t?t:0),Lr(Vs(e),t,n)},pr.clone=function(e){return Or(e,h)},pr.cloneDeep=function(e){return Or(e,c|h)},pr.cloneDeepWith=function(e,t){return Or(e,c|h,t="function"==typeof t?t:r)},pr.cloneWith=function(e,t){return Or(e,h,t="function"==typeof t?t:r)},pr.conformsTo=function(e,t){return null==t||zr(e,t,iu(t))},pr.deburr=vu,pr.defaultTo=function(e,t){return null==e||e!=e?t:e},pr.divide=Gu,pr.endsWith=function(e,t,n){e=Ws(e),t=zi(t);var i=e.length,a=n=n===r?i:Lr(Us(n),0,i);return(n-=t.length)>=0&&e.slice(n,a)==t},pr.eq=ps,pr.escape=function(e){return(e=Ws(e))&&ke.test(e)?e.replace(ye,yn):e},pr.escapeRegExp=function(e){return(e=Ws(e))&&Re.test(e)?e.replace(Ie,"\\$&"):e},pr.every=function(e,t,n){var i=ms(e)?Ht:Ur;return n&&Ga(e,t,n)&&(t=r),i(e,Oa(t,3))},pr.find=Vo,pr.findIndex=vo,pr.findKey=function(e,t){return rn(e,Oa(t,3),Hr)},pr.findLast=Zo,pr.findLastIndex=mo,pr.findLastKey=function(e,t){return rn(e,Oa(t,3),Yr)},pr.floor=Hu,pr.forEach=Wo,pr.forEachRight=Go,pr.forIn=function(e,t){return null==e?e:Wr(e,Oa(t,3),au)},pr.forInRight=function(e,t){return null==e?e:Gr(e,Oa(t,3),au)},pr.forOwn=function(e,t){return e&&Hr(e,Oa(t,3))},pr.forOwnRight=function(e,t){return e&&Yr(e,Oa(t,3))},pr.get=Qs,pr.gt=ds,pr.gte=gs,pr.has=function(e,t){return null!=e&&qa(e,t,ei)},pr.hasIn=eu,pr.head=wo,pr.identity=Iu,pr.includes=function(e,t,n,r){e=ws(e)?e:pu(e),n=n&&!r?Us(n):0;var i=e.length;return n<0&&(n=Wn(i+n,0)),Ls(e)?n<=i&&e.indexOf(t,n)>-1:!!i&&on(e,t,n)>-1},pr.indexOf=function(e,t,n){var r=null==e?0:e.length;if(!r)return-1;var i=null==n?0:Us(n);return i<0&&(i=Wn(r+i,0)),on(e,t,i)},pr.inRange=function(e,t,n){return t=Ps(t),n===r?(n=t,t=0):n=Ps(n),function(e,t,n){return e>=Gn(t,n)&&e=-C&&e<=C},pr.isSet=Bs,pr.isString=Ls,pr.isSymbol=Os,pr.isTypedArray=zs,pr.isUndefined=function(e){return e===r},pr.isWeakMap=function(e){return Ts(e)&&Ua(e)==ie},pr.isWeakSet=function(e){return Ts(e)&&Kr(e)==ae},pr.join=function(e,t){return null==e?"":Vn.call(e,t)},pr.kebabCase=mu,pr.last=ko,pr.lastIndexOf=function(e,t,n){var i=null==e?0:e.length;if(!i)return-1;var a=i;return n!==r&&(a=(a=Us(n))<0?Wn(i+a,0):Gn(a,i-1)),t==t?function(e,t,n){for(var r=n+1;r--;)if(e[r]===t)return r;return r}(e,t,a):an(e,un,a,!0)},pr.lowerCase=_u,pr.lowerFirst=wu,pr.lt=Ds,pr.lte=Fs,pr.max=function(e){return e&&e.length?qr(e,Iu,Qr):r},pr.maxBy=function(e,t){return e&&e.length?qr(e,Oa(t,2),Qr):r},pr.mean=function(e){return ln(e,Iu)},pr.meanBy=function(e,t){return ln(e,Oa(t,2))},pr.min=function(e){return e&&e.length?qr(e,Iu,fi):r},pr.minBy=function(e,t){return e&&e.length?qr(e,Oa(t,2),fi):r},pr.stubArray=qu,pr.stubFalse=Vu,pr.stubObject=function(){return{}},pr.stubString=function(){return""},pr.stubTrue=function(){return!0},pr.multiply=$u,pr.nth=function(e,t){return e&&e.length?vi(e,Us(t)):r},pr.noConflict=function(){return Rt._===this&&(Rt._=gt),this},pr.noop=Ou,pr.now=Qo,pr.pad=function(e,t,n){e=Ws(e);var r=(t=Us(t))?jn(e):0;if(!t||r>=t)return e;var i=(t-r)/2;return ma(Nn(i),n)+e+ma(Fn(i),n)},pr.padEnd=function(e,t,n){e=Ws(e);var r=(t=Us(t))?jn(e):0;return t&&rt){var i=e;e=t,t=i}if(n||e%1||t%1){var a=$n();return Gn(e+a*(t-e+Mt("1e-"+((a+"").length-1))),t)}return yi(e,t)},pr.reduce=function(e,t,n){var r=ms(e)?Qt:hn,i=arguments.length<3;return r(e,Oa(t,4),n,i,Nr)},pr.reduceRight=function(e,t,n){var r=ms(e)?en:hn,i=arguments.length<3;return r(e,Oa(t,4),n,i,Pr)},pr.repeat=function(e,t,n){return t=(n?Ga(e,t,n):t===r)?1:Us(t),xi(Ws(e),t)},pr.replace=function(){var e=arguments,t=Ws(e[0]);return e.length<3?t:t.replace(e[1],e[2])},pr.result=function(e,t,n){var i=-1,a=(t=Gi(t,e)).length;for(a||(a=1,e=r);++iC)return[];var n=O,r=Gn(e,O);t=Oa(t),e-=O;for(var i=dn(r,t);++n=o)return e;var u=n-jn(i);if(u<1)return i;var l=s?Yi(s,0,u).join(""):e.slice(0,u);if(a===r)return l+i;if(s&&(u+=l.length-u),Cs(a)){if(e.slice(u).search(a)){var c,f=l;for(a.global||(a=nt(a.source,Ws(Ue.exec(a))+"g")),a.lastIndex=0;c=a.exec(f);)var h=c.index;l=l.slice(0,h===r?u:h)}}else if(e.indexOf(zi(a),u)!=u){var p=l.lastIndexOf(a);p>-1&&(l=l.slice(0,p))}return l+i},pr.unescape=function(e){return(e=Ws(e))&&xe.test(e)?e.replace(be,Rn):e},pr.uniqueId=function(e){var t=++ft;return Ws(e)+t},pr.upperCase=xu,pr.upperFirst=ku,pr.each=Wo,pr.eachRight=Go,pr.first=wo,Lu(pr,(Yu={},Hr(pr,function(e,t){ct.call(pr.prototype,t)||(Yu[t]=e)}),Yu),{chain:!1}),pr.VERSION="4.17.11",Wt(["bind","bindKey","curry","curryRight","partial","partialRight"],function(e){pr[e].placeholder=pr}),Wt(["drop","take"],function(e,t){mr.prototype[e]=function(n){n=n===r?1:Wn(Us(n),0);var i=this.__filtered__&&!t?new mr(this):this.clone();return i.__filtered__?i.__takeCount__=Gn(n,i.__takeCount__):i.__views__.push({size:Gn(n,O),type:e+(i.__dir__<0?"Right":"")}),i},mr.prototype[e+"Right"]=function(t){return this.reverse()[e](t).reverse()}}),Wt(["filter","map","takeWhile"],function(e,t){var n=t+1,r=n==j||3==n;mr.prototype[e]=function(e){var t=this.clone();return t.__iteratees__.push({iteratee:Oa(e,3),type:n}),t.__filtered__=t.__filtered__||r,t}}),Wt(["head","last"],function(e,t){var n="take"+(t?"Right":"");mr.prototype[e]=function(){return this[n](1).value()[0]}}),Wt(["initial","tail"],function(e,t){var n="drop"+(t?"":"Right");mr.prototype[e]=function(){return this.__filtered__?new mr(this):this[n](1)}}),mr.prototype.compact=function(){return this.filter(Iu)},mr.prototype.find=function(e){return this.filter(e).head()},mr.prototype.findLast=function(e){return this.reverse().find(e)},mr.prototype.invokeMap=ki(function(e,t){return"function"==typeof e?new mr(this):this.map(function(n){return ri(n,e,t)})}),mr.prototype.reject=function(e){return this.filter(us(Oa(e)))},mr.prototype.slice=function(e,t){e=Us(e);var n=this;return n.__filtered__&&(e>0||t<0)?new mr(n):(e<0?n=n.takeRight(-e):e&&(n=n.drop(e)),t!==r&&(n=(t=Us(t))<0?n.dropRight(-t):n.take(t-e)),n)},mr.prototype.takeRightWhile=function(e){return this.reverse().takeWhile(e).reverse()},mr.prototype.toArray=function(){return this.take(O)},Hr(mr.prototype,function(e,t){var n=/^(?:filter|find|map|reject)|While$/.test(t),i=/^(?:head|last)$/.test(t),a=pr[i?"take"+("last"==t?"Right":""):t],o=i||/^find/.test(t);a&&(pr.prototype[t]=function(){var t=this.__wrapped__,s=i?[1]:arguments,u=t instanceof mr,l=s[0],c=u||ms(t),f=function(e){var t=a.apply(pr,Kt([e],s));return i&&h?t[0]:t};c&&n&&"function"==typeof l&&1!=l.length&&(u=c=!1);var h=this.__chain__,p=!!this.__actions__.length,d=o&&!h,g=u&&!p;if(!o&&c){t=g?t:new mr(this);var v=e.apply(t,s);return v.__actions__.push({func:Po,args:[f],thisArg:r}),new vr(v,h)}return d&&g?e.apply(this,s):(v=this.thru(f),d?i?v.value()[0]:v.value():v)})}),Wt(["pop","push","shift","sort","splice","unshift"],function(e){var t=at[e],n=/^(?:push|sort|unshift)$/.test(e)?"tap":"thru",r=/^(?:pop|shift)$/.test(e);pr.prototype[e]=function(){var e=arguments;if(r&&!this.__chain__){var i=this.value();return t.apply(ms(i)?i:[],e)}return this[n](function(n){return t.apply(ms(n)?n:[],e)})}}),Hr(mr.prototype,function(e,t){var n=pr[t];if(n){var r=n.name+"";(ir[r]||(ir[r]=[])).push({name:t,func:n})}}),ir[pa(r,v).name]=[{name:"wrapper",func:r}],mr.prototype.clone=function(){var e=new mr(this.__wrapped__);return e.__actions__=na(this.__actions__),e.__dir__=this.__dir__,e.__filtered__=this.__filtered__,e.__iteratees__=na(this.__iteratees__),e.__takeCount__=this.__takeCount__,e.__views__=na(this.__views__),e},mr.prototype.reverse=function(){if(this.__filtered__){var e=new mr(this);e.__dir__=-1,e.__filtered__=!0}else(e=this.clone()).__dir__*=-1;return e},mr.prototype.value=function(){var e=this.__wrapped__.value(),t=this.__dir__,n=ms(e),r=t<0,i=n?e.length:0,a=function(e,t,n){for(var r=-1,i=n.length;++r=this.__values__.length;return{done:e,value:e?r:this.__values__[this.__index__++]}},pr.prototype.plant=function(e){for(var t,n=this;n instanceof gr;){var i=fo(n);i.__index__=0,i.__values__=r,t?a.__wrapped__=i:t=i;var a=i;n=n.__wrapped__}return a.__wrapped__=e,t},pr.prototype.reverse=function(){var e=this.__wrapped__;if(e instanceof mr){var t=e;return this.__actions__.length&&(t=new mr(this)),(t=t.reverse()).__actions__.push({func:Po,args:[Mo],thisArg:r}),new vr(t,this.__chain__)}return this.thru(Mo)},pr.prototype.toJSON=pr.prototype.valueOf=pr.prototype.value=function(){return Ui(this.__wrapped__,this.__actions__)},pr.prototype.first=pr.prototype.head,fn&&(pr.prototype[fn]=function(){return this}),pr}();"function"==typeof define&&"object"==typeof define.amd&&define.amd?(Rt._=Cn,define(function(){return Cn})):Bt?((Bt.exports=Cn)._=Cn,Ct._=Cn):Rt._=Cn}).call(this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],63:[function(e,t,n){(function(n){e("path");var r=e("fs");function i(){this.types=Object.create(null),this.extensions=Object.create(null)}i.prototype.define=function(e){for(var t in e){for(var r=e[t],i=0;i=0;--s)if(h[s]=f,f*=l[s],p=Math.max(p,o.scratchMemory(l[s])),t.shape[s]!==n.shape[s])throw new Error("Shape mismatch, real and imaginary arrays must have same size");var d,g=4*f+p;d="array"===t.dtype||"float64"===t.dtype||"custom"===t.dtype?a.mallocDouble(g):a.mallocFloat(g);var v,m,_,w,b=i(d,l.slice(0),h,0),y=i(d,l.slice(0),h.slice(0),f),x=i(d,l.slice(0),h.slice(0),2*f),k=i(d,l.slice(0),h.slice(0),3*f),E=4*f;for(r.assign(b,t),r.assign(y,n),s=c-1;s>=0&&(o(e,f/l[s],l[s],d,b.offset,y.offset,E),0!==s);--s){for(m=1,_=x.stride,w=k.stride,u=s-1;u=0;--u)w[u]=_[u]=m,m*=l[u];r.assign(x,b),r.assign(k,y),v=b,b=x,x=v,v=y,y=k,k=v}r.assign(t,b),r.assign(n,y),a.free(d)}},{"./lib/fft-matrix.js":66,ndarray:71,"ndarray-ops":68,"typedarray-pool":130}],66:[function(e,t,n){var r=e("bit-twiddle");function i(e,t,n,i,a,o){var s,u,l,c,f,h,p,d,g,v,m,_,w,b,y,x,k,E,S,A,M,T,j,I;for(e|=0,t|=0,a|=0,o|=0,s=n|=0,u=r.log2(s),E=0;E>1,f=0,l=0;l>=1;f+=h}for(m=-1,_=0,v=1,d=0;d>",rrshift:">>>"};!function(){for(var e in s){var t=s[e];n[e]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+t+"c"},funcName:e}),n[e+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a"+t+"=b"},rvalue:!0,funcName:e+"eq"}),n[e+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+t+"s"},funcName:e+"s"}),n[e+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a"+t+"=s"},rvalue:!0,funcName:e+"seq"})}}();var u={not:"!",bnot:"~",neg:"-",recip:"1.0/"};!function(){for(var e in u){var t=u[e];n[e]=o({args:["array","array"],body:{args:["a","b"],body:"a="+t+"b"},funcName:e}),n[e+"eq"]=o({args:["array"],body:{args:["a"],body:"a="+t+"a"},rvalue:!0,count:2,funcName:e+"eq"})}}();var l={and:"&&",or:"||",eq:"===",neq:"!==",lt:"<",gt:">",leq:"<=",geq:">="};!function(){for(var e in l){var t=l[e];n[e]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+t+"c"},funcName:e}),n[e+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+t+"s"},funcName:e+"s"}),n[e+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a=a"+t+"b"},rvalue:!0,count:2,funcName:e+"eq"}),n[e+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a=a"+t+"s"},rvalue:!0,count:2,funcName:e+"seq"})}}();var c=["abs","acos","asin","atan","ceil","cos","exp","floor","log","round","sin","sqrt","tan"];!function(){for(var e=0;ethis_s){this_s=-a}else if(a>this_s){this_s=a}",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norminf"}),n.norm1=r({args:["array"],pre:{args:[],localVars:[],thisVars:["this_s"],body:"this_s=0"},body:{args:[{name:"a",lvalue:!1,rvalue:!0,count:3}],body:"this_s+=a<0?-a:a",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norm1"}),n.sup=r({args:["array"],pre:{body:"this_h=-Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_>this_h)this_h=_inline_1_arg0_",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_h"],localVars:[]},post:{body:"return this_h",args:[],thisVars:["this_h"],localVars:[]}}),n.inf=r({args:["array"],pre:{body:"this_h=Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_this_v){this_v=_inline_1_arg1_;for(var _inline_1_k=0;_inline_1_k<_inline_1_arg0_.length;++_inline_1_k){this_i[_inline_1_k]=_inline_1_arg0_[_inline_1_k]}}}",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_i","this_v"],localVars:["_inline_1_k"]},post:{body:"{return this_i}",args:[],thisVars:["this_i"],localVars:[]}}),n.random=o({args:["array"],pre:{args:[],body:"this_f=Math.random",thisVars:["this_f"]},body:{args:["a"],body:"a=this_f()",thisVars:["this_f"]},funcName:"random"}),n.assign=o({args:["array","array"],body:{args:["a","b"],body:"a=b"},funcName:"assign"}),n.assigns=o({args:["array","scalar"],body:{args:["a","b"],body:"a=b"},funcName:"assigns"}),n.equals=r({args:["array","array"],pre:i,body:{args:[{name:"x",lvalue:!1,rvalue:!0,count:1},{name:"y",lvalue:!1,rvalue:!0,count:1}],body:"if(x!==y){return false}",localVars:[],thisVars:[]},post:{args:[],localVars:[],thisVars:[],body:"return true"},funcName:"equals"})},{"cwise-compiler":9}],69:[function(e,t,n){"use strict";var r=e("ndarray"),i=e("./doConvert.js");t.exports=function(e,t){for(var n=[],a=e,o=1;Array.isArray(a);)n.push(a.length),o*=a.length,a=a[0];return 0===n.length?r():(t||(t=r(new Float64Array(o),n)),i(t,e),t)}},{"./doConvert.js":70,ndarray:71}],70:[function(e,t,n){t.exports=e("cwise-compiler")({args:["array","scalar","index"],pre:{body:"{}",args:[],thisVars:[],localVars:[]},body:{body:"{\nvar _inline_1_v=_inline_1_arg1_,_inline_1_i\nfor(_inline_1_i=0;_inline_1_i<_inline_1_arg2_.length-1;++_inline_1_i) {\n_inline_1_v=_inline_1_v[_inline_1_arg2_[_inline_1_i]]\n}\n_inline_1_arg0_=_inline_1_v[_inline_1_arg2_[_inline_1_arg2_.length-1]]\n}",args:[{name:"_inline_1_arg0_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg2_",lvalue:!1,rvalue:!0,count:4}],thisVars:[],localVars:["_inline_1_i","_inline_1_v"]},post:{body:"{}",args:[],thisVars:[],localVars:[]},funcName:"convert",blockSize:64})},{"cwise-compiler":9}],71:[function(e,t,n){var r=e("iota-array"),i=e("is-buffer"),a="undefined"!=typeof Float64Array;function o(e,t){return e[0]-t[0]}function s(){var e,t=this.stride,n=new Array(t.length);for(e=0;eMath.abs(this.stride[1]))?[1,0]:[0,1]}})"):3===t&&a.push("var s0=Math.abs(this.stride[0]),s1=Math.abs(this.stride[1]),s2=Math.abs(this.stride[2]);if(s0>s1){if(s1>s2){return [2,1,0];}else if(s0>s2){return [1,2,0];}else{return [1,0,2];}}else if(s0>s2){return [2,0,1];}else if(s2>s1){return [0,1,2];}else{return [0,2,1];}}})")):a.push("ORDER})")),a.push("proto.set=function "+n+"_set("+u.join(",")+",v){"),i?a.push("return this.data.set("+c+",v)}"):a.push("return this.data["+c+"]=v}"),a.push("proto.get=function "+n+"_get("+u.join(",")+"){"),i?a.push("return this.data.get("+c+")}"):a.push("return this.data["+c+"]}"),a.push("proto.index=function "+n+"_index(",u.join(),"){return "+c+"}"),a.push("proto.hi=function "+n+"_hi("+u.join(",")+"){return new "+n+"(this.data,"+o.map(function(e){return["(typeof i",e,"!=='number'||i",e,"<0)?this.shape[",e,"]:i",e,"|0"].join("")}).join(",")+","+o.map(function(e){return"this.stride["+e+"]"}).join(",")+",this.offset)}");var p=o.map(function(e){return"a"+e+"=this.shape["+e+"]"}),d=o.map(function(e){return"c"+e+"=this.stride["+e+"]"});a.push("proto.lo=function "+n+"_lo("+u.join(",")+"){var b=this.offset,d=0,"+p.join(",")+","+d.join(","));for(var g=0;g=0){d=i"+g+"|0;b+=c"+g+"*d;a"+g+"-=d}");a.push("return new "+n+"(this.data,"+o.map(function(e){return"a"+e}).join(",")+","+o.map(function(e){return"c"+e}).join(",")+",b)}"),a.push("proto.step=function "+n+"_step("+u.join(",")+"){var "+o.map(function(e){return"a"+e+"=this.shape["+e+"]"}).join(",")+","+o.map(function(e){return"b"+e+"=this.stride["+e+"]"}).join(",")+",c=this.offset,d=0,ceil=Math.ceil");for(g=0;g=0){c=(c+this.stride["+g+"]*i"+g+")|0}else{a.push(this.shape["+g+"]);b.push(this.stride["+g+"])}");return a.push("var ctor=CTOR_LIST[a.length+1];return ctor(this.data,a,b,c)}"),a.push("return function construct_"+n+"(data,shape,stride,offset){return new "+n+"(data,"+o.map(function(e){return"shape["+e+"]"}).join(",")+","+o.map(function(e){return"stride["+e+"]"}).join(",")+",offset)}"),new Function("CTOR_LIST","ORDER",a.join("\n"))(l[e],s)}var l={float32:[],float64:[],int8:[],int16:[],int32:[],uint8:[],uint16:[],uint32:[],array:[],uint8_clamped:[],buffer:[],generic:[]};t.exports=function(e,t,n,r){if(void 0===e)return(0,l.array[0])([]);"number"==typeof e&&(e=[e]),void 0===t&&(t=[e.length]);var o=t.length;if(void 0===n){n=new Array(o);for(var s=o-1,c=1;s>=0;--s)n[s]=c,c*=t[s]}if(void 0===r)for(r=0,s=0;s>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,(e|=e>>>16)+1}},{}],73:[function(e,t,n){"use strict";function r(e,t,n,r){for(var i=e[t++],a=1<>=u,c-=u,v!==a){if(v===o)break;for(var m=va;)w=d[w]>>8,++_;var b=w;if(h+_+(m!==v?1:0)>r)return void console.log("Warning, gif stream longer than expected.");n[h++]=b;var y=h+=_;for(m!==v&&(n[h++]=b),w=m;_--;)w=d[w],n[--y]=255&w,w>>=8;null!==g&&s<4096&&(d[s++]=g<<8|b,s>=l+1&&u<12&&(++u,l=l<<1|1)),g=v}else s=o+1,l=(1<<(u=i+1))-1,g=null}return h!==r&&console.log("Warning, gif stream shorter than expected."),n}try{n.GifWriter=function(e,t,n,r){var i=0,a=void 0===(r=void 0===r?{}:r).loop?null:r.loop,o=void 0===r.palette?null:r.palette;if(t<=0||n<=0||t>65535||n>65535)throw new Error("Width/Height invalid.");function s(e){var t=e.length;if(t<2||t>256||t&t-1)throw new Error("Invalid code/color length, must be power of 2 and 2 .. 256.");return t}e[i++]=71,e[i++]=73,e[i++]=70,e[i++]=56,e[i++]=57,e[i++]=97;var u=0,l=0;if(null!==o){for(var c=s(o);c>>=1;)++u;if(c=1<=c)throw new Error("Background index out of range.");if(0===l)throw new Error("Background index explicitly passed as 0.")}}if(e[i++]=255&t,e[i++]=t>>8&255,e[i++]=255&n,e[i++]=n>>8&255,e[i++]=(null!==o?128:0)|u,e[i++]=l,e[i++]=0,null!==o)for(var f=0,h=o.length;f>16&255,e[i++]=p>>8&255,e[i++]=255&p}if(null!==a){if(a<0||a>65535)throw new Error("Loop count invalid.");e[i++]=33,e[i++]=255,e[i++]=11,e[i++]=78,e[i++]=69,e[i++]=84,e[i++]=83,e[i++]=67,e[i++]=65,e[i++]=80,e[i++]=69,e[i++]=50,e[i++]=46,e[i++]=48,e[i++]=3,e[i++]=1,e[i++]=255&a,e[i++]=a>>8&255,e[i++]=0}var d=!1;this.addFrame=function(t,n,r,a,u,l){if(!0===d&&(--i,d=!1),l=void 0===l?{}:l,t<0||n<0||t>65535||n>65535)throw new Error("x/y invalid.");if(r<=0||a<=0||r>65535||a>65535)throw new Error("Width/Height invalid.");if(u.length>=1;)++p;h=1<3)throw new Error("Disposal out of range.");var m=!1,_=0;if(void 0!==l.transparent&&null!==l.transparent&&(m=!0,(_=l.transparent)<0||_>=h))throw new Error("Transparent color index.");if((0!==v||m||0!==g)&&(e[i++]=33,e[i++]=249,e[i++]=4,e[i++]=v<<2|(!0===m?1:0),e[i++]=255&g,e[i++]=g>>8&255,e[i++]=_,e[i++]=0),e[i++]=44,e[i++]=255&t,e[i++]=t>>8&255,e[i++]=255&n,e[i++]=n>>8&255,e[i++]=255&r,e[i++]=r>>8&255,e[i++]=255&a,e[i++]=a>>8&255,e[i++]=!0===c?128|p-1:0,!0===c)for(var w=0,b=f.length;w>16&255,e[i++]=y>>8&255,e[i++]=255&y}return i=function(e,t,n,r){e[t++]=n;var i=t++,a=1<=n;)e[t++]=255&f,f>>=8,c-=8,t===i+256&&(e[i]=255,i=t++)}function p(e){f|=e<=8;)e[t++]=255&f,f>>=8,c-=8,t===i+256&&(e[i]=255,i=t++);4096===u?(p(a),u=s+1,l=n+1,g={}):(u>=1<>7,s=1<<1+(7&a);e[t++],e[t++];var u=null,l=null;o&&(u=t,l=s,t+=3*s);var c=!0,f=[],h=0,p=null,d=0,g=null;for(this.width=n,this.height=i;c&&t=0))throw Error("Invalid block size");if(0===T)break;t+=T}break;case 249:if(4!==e[t++]||0!==e[t+4])throw new Error("Invalid graphics extension block.");var v=e[t++];h=e[t++]|e[t++]<<8,p=e[t++],0==(1&v)&&(p=null),d=v>>2&7,t++;break;case 254:for(;;){if(!((T=e[t++])>=0))throw Error("Invalid block size");if(0===T)break;t+=T}break;default:throw new Error("Unknown graphic control label: 0x"+e[t-1].toString(16))}break;case 44:var m=e[t++]|e[t++]<<8,_=e[t++]|e[t++]<<8,w=e[t++]|e[t++]<<8,b=e[t++]|e[t++]<<8,y=e[t++],x=y>>6&1,k=1<<1+(7&y),E=u,S=l,A=!1;y>>7&&(A=!0,E=t,S=k,t+=3*k);var M=t;for(t++;;){var T;if(!((T=e[t++])>=0))throw Error("Invalid block size");if(0===T)break;t+=T}f.push({x:m,y:_,width:w,height:b,has_local_palette:A,palette_offset:E,palette_size:S,data_offset:M,data_length:t-M,transparent_index:p,interlaced:!!x,delay:h,disposal:d});break;case 59:c=!1;break;default:throw new Error("Unknown gif block: 0x"+e[t-1].toString(16))}this.numFrames=function(){return f.length},this.loopCount=function(){return g},this.frameInfo=function(e){if(e<0||e>=f.length)throw new Error("Frame index out of range.");return f[e]},this.decodeAndBlitFrameBGRA=function(t,i){var a=this.frameInfo(t),o=a.width*a.height,s=new Uint8Array(o);r(e,a.data_offset,s,o);var u=a.palette_offset,l=a.transparent_index;null===l&&(l=256);var c=a.width,f=n-c,h=c,p=4*(a.y*n+a.x),d=4*((a.y+a.height)*n+a.x),g=p,v=4*f;!0===a.interlaced&&(v+=4*n*7);for(var m=8,_=0,w=s.length;_=d&&(v=4*f+4*n*(m-1),g=p+(c+f)*(m<<1),m>>=1)),b===l)g+=4;else{var y=e[u+3*b],x=e[u+3*b+1],k=e[u+3*b+2];i[g++]=k,i[g++]=x,i[g++]=y,i[g++]=255}--h}},this.decodeAndBlitFrameRGBA=function(t,i){var a=this.frameInfo(t),o=a.width*a.height,s=new Uint8Array(o);r(e,a.data_offset,s,o);var u=a.palette_offset,l=a.transparent_index;null===l&&(l=256);var c=a.width,f=n-c,h=c,p=4*(a.y*n+a.x),d=4*((a.y+a.height)*n+a.x),g=p,v=4*f;!0===a.interlaced&&(v+=4*n*7);for(var m=8,_=0,w=s.length;_=d&&(v=4*f+4*n*(m-1),g=p+(c+f)*(m<<1),m>>=1)),b===l)g+=4;else{var y=e[u+3*b],x=e[u+3*b+1],k=e[u+3*b+2];i[g++]=y,i[g++]=x,i[g++]=k,i[g++]=255}--h}}}}catch(e){}},{}],74:[function(e,t,n){(function(n){var r=e("charm");function i(e){if(!(e=e||{}).total)throw new Error("You MUST specify the total number of operations that will be processed.");this.total=e.total,this.current=0,this.max_burden=e.maxBurden||.5,this.show_burden=e.showBurden||!1,this.started=!1,this.size=50,this.inner_time=0,this.outer_time=0,this.elapsed=0,this.time_start=0,this.time_end=0,this.time_left=0,this.time_burden=0,this.skip_steps=0,this.skipped=0,this.aborted=!1,this.charm=r(),this.charm.pipe(n.stdout),this.charm.write("\n\n\n")}function a(e,t,n){for(n=n||" ";e.length3&&(u[0]=u[0].replace(/\B(?=(?:\d{3})+(?!\d))/g,o)),(u[1]||"").length=this.total&&this.finished(),this.time_end=(new Date).getTime(),this.inner_time=this.time_end-this.time_start)},i.prototype.updateTimes=function(){this.elapsed=this.time_start-this.started,this.time_end>0&&(this.outer_time=this.time_start-this.time_end),this.inner_time>0&&this.outer_time>0&&(this.time_burden=this.inner_time/(this.inner_time+this.outer_time)*100,this.time_left=this.elapsed/this.current*(this.total-this.current),this.time_left<0&&(this.time_left=0)),this.time_burden>this.max_burden&&this.skip_steps0&&this.current=0;r--){var i=e[r];"."===i?e.splice(r,1):".."===i?(e.splice(r,1),n++):n&&(e.splice(r,1),n--)}if(t)for(;n--;n)e.unshift("..");return e}function r(e,t){if(e.filter)return e.filter(t);for(var n=[],r=0;r=-1&&!i;a--){var o=a>=0?arguments[a]:e.cwd();if("string"!=typeof o)throw new TypeError("Arguments to path.resolve must be strings");o&&(n=o+"/"+n,i="/"===o.charAt(0))}return n=t(r(n.split("/"),function(e){return!!e}),!i).join("/"),(i?"/":"")+n||"."},n.normalize=function(e){var a=n.isAbsolute(e),o="/"===i(e,-1);return(e=t(r(e.split("/"),function(e){return!!e}),!a).join("/"))||a||(e="."),e&&o&&(e+="/"),(a?"/":"")+e},n.isAbsolute=function(e){return"/"===e.charAt(0)},n.join=function(){var e=Array.prototype.slice.call(arguments,0);return n.normalize(r(e,function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e}).join("/"))},n.relative=function(e,t){function r(e){for(var t=0;t=0&&""===e[n];n--);return t>n?[]:e.slice(t,n-t+1)}e=n.resolve(e).substr(1),t=n.resolve(t).substr(1);for(var i=r(e.split("/")),a=r(t.split("/")),o=Math.min(i.length,a.length),s=o,u=0;u=1;--a)if(47===(t=e.charCodeAt(a))){if(!i){r=a;break}}else i=!1;return-1===r?n?"/":".":n&&1===r?"/":e.slice(0,r)},n.basename=function(e,t){var n=function(e){"string"!=typeof e&&(e+="");var t,n=0,r=-1,i=!0;for(t=e.length-1;t>=0;--t)if(47===e.charCodeAt(t)){if(!i){n=t+1;break}}else-1===r&&(i=!1,r=t+1);return-1===r?"":e.slice(n,r)}(e);return t&&n.substr(-1*t.length)===t&&(n=n.substr(0,n.length-t.length)),n},n.extname=function(e){"string"!=typeof e&&(e+="");for(var t=-1,n=0,r=-1,i=!0,a=0,o=e.length-1;o>=0;--o){var s=e.charCodeAt(o);if(47!==s)-1===r&&(i=!1,r=o+1),46===s?-1===t?t=o:1!==a&&(a=1):-1!==t&&(a=-1);else if(!i){n=o+1;break}}return-1===t||-1===r||0===a||1===a&&t===r-1&&t===n+1?"":e.slice(t,r)};var i="b"==="ab".substr(-1)?function(e,t,n){return e.substr(t,n)}:function(e,t,n){return t<0&&(t=e.length+t),e.substr(t,n)}}).call(this,e("_process"))},{_process:98}],76:[function(e,t,n){(function(t){"use strict";var r=e("./interlace"),i={1:{0:0,1:0,2:0,3:255},2:{0:0,1:0,2:0,3:1},3:{0:0,1:1,2:2,3:255},4:{0:0,1:1,2:2,3:3}};function a(e,t,n,r,a,o){for(var s=e.width,u=e.height,l=e.index,c=0;c>4,n.push(f,c);break;case 2:u=3&h,l=h>>2&3,c=h>>4&3,f=h>>6&3,n.push(f,c,l,u);break;case 1:i=1&h,a=h>>1&1,o=h>>2&1,s=h>>3&1,u=h>>4&1,l=h>>5&1,c=h>>6&1,f=h>>7&1,n.push(f,c,l,u,s,o,a,i)}}return{get:function(e){for(;n.length0&&(this._paused=!1,this.emit("drain"))}.bind(this))},o.prototype.write=function(e,t){return this.writable?(n=r.isBuffer(e)?e:new r(e,t||this._encoding),this._buffers.push(n),this._buffered+=n.length,this._process(),this._reads&&0===this._reads.length&&(this._paused=!0),this.writable&&!this._paused):(this.emit("error",new Error("Stream not writable")),!1);var n},o.prototype.end=function(e,t){e&&this.write(e,t),this.writable=!1,this._buffers&&(0===this._buffers.length?this._end():(this._buffers.push(null),this._process()))},o.prototype.destroySoon=o.prototype.end,o.prototype._end=function(){this._reads.length>0&&this.emit("error",new Error("There are some read requests waitng on finished stream")),this.destroy()},o.prototype.destroy=function(){this._buffers&&(this.writable=!1,this._reads=null,this._buffers=null,this.emit("close"))},o.prototype._processReadAllowingLess=function(e){this._reads.shift();var t=this._buffers[0];t.length>e.length?(this._buffered-=e.length,this._buffers[0]=t.slice(e.length),e.func.call(this,t.slice(0,e.length))):(this._buffered-=t.length,this._buffers.shift(),e.func.call(this,t))},o.prototype._processRead=function(e){this._reads.shift();for(var t=0,n=0,i=new r(e.length);t0&&this._buffers.splice(0,n),this._buffered-=e.length,e.func.call(this,i)},o.prototype._process=function(){try{for(;this._buffered>0&&this._reads&&this._reads.length>0;){var e=this._reads[0];if(e.allowLess)this._processReadAllowingLess(e);else{if(!(this._buffered>=e.length))break;this._processRead(e)}}this._buffers&&this._buffers.length>0&&null===this._buffers[0]&&this._end()}catch(e){this.emit("error",e)}}}).call(this,e("_process"),e("buffer").Buffer)},{_process:98,buffer:4,stream:112,util:135}],79:[function(e,t,n){"use strict";t.exports={PNG_SIGNATURE:[137,80,78,71,13,10,26,10],TYPE_IHDR:1229472850,TYPE_IEND:1229278788,TYPE_IDAT:1229209940,TYPE_PLTE:1347179589,TYPE_tRNS:1951551059,TYPE_gAMA:1732332865,COLORTYPE_GRAYSCALE:0,COLORTYPE_PALETTE:1,COLORTYPE_COLOR:2,COLORTYPE_ALPHA:4,COLORTYPE_PALETTE_COLOR:3,COLORTYPE_COLOR_ALPHA:6,COLORTYPE_TO_BPP_MAP:{0:1,2:3,3:1,4:2,6:4},GAMMA_DIVISION:1e5}},{}],80:[function(e,t,n){"use strict";var r=[];!function(){for(var e=0;e<256;e++){for(var t=e,n=0;n<8;n++)1&t?t=3988292384^t>>>1:t>>>=1;r[e]=t}}();var i=t.exports=function(){this._crc=-1};i.prototype.write=function(e){for(var t=0;t>>8;return!0},i.prototype.crc32=function(){return-1^this._crc},i.crc32=function(e){for(var t=-1,n=0;n>>8;return-1^t}},{}],81:[function(e,t,n){(function(n){"use strict";var r=e("./paeth-predictor");var i={0:function(e,t,n,r,i){e.copy(r,i,t,t+n)},1:function(e,t,n,r,i,a){for(var o=0;o=a?e[t+o-a]:0,u=e[t+o]-s;r[i+o]=u}},2:function(e,t,n,r,i){for(var a=0;a0?e[t+a-n]:0,s=e[t+a]-o;r[i+a]=s}},3:function(e,t,n,r,i,a){for(var o=0;o=a?e[t+o-a]:0,u=t>0?e[t+o-n]:0,l=e[t+o]-(s+u>>1);r[i+o]=l}},4:function(e,t,n,i,a,o){for(var s=0;s=o?e[t+s-o]:0,l=t>0?e[t+s-n]:0,c=t>0&&s>=o?e[t+s-(n+o)]:0,f=e[t+s]-r(u,l,c);i[a+s]=f}}},a={0:function(e,t,n){for(var r=0,i=t+n,a=t;a=r?e[t+a-r]:0,s=e[t+a]-o;i+=Math.abs(s)}return i},2:function(e,t,n){for(var r=0,i=t+n,a=t;a0?e[a-n]:0,s=e[a]-o;r+=Math.abs(s)}return r},3:function(e,t,n,r){for(var i=0,a=0;a=r?e[t+a-r]:0,s=t>0?e[t+a-n]:0,u=e[t+a]-(o+s>>1);i+=Math.abs(u)}return i},4:function(e,t,n,i){for(var a=0,o=0;o=i?e[t+o-i]:0,u=t>0?e[t+o-n]:0,l=t>0&&o>=i?e[t+o-(n+i)]:0,c=e[t+o]-r(s,u,l);a+=Math.abs(c)}return a}};t.exports=function(e,t,r,o,s){var u;if("filterType"in o&&-1!==o.filterType){if("number"!=typeof o.filterType)throw new Error("unrecognised filter types");u=[o.filterType]}else u=[0,1,2,3,4];for(var l=t*s,c=0,f=0,h=new n((l+1)*r),p=u[0],d=0;d1)for(var g=1/0,v=0;vi?t[a-r]:0;t[a]=o+s}},o.prototype._unFilterType2=function(e,t,n){for(var r=this._lastLine,i=0;ii?t[o-r]:0,c=Math.floor((l+u)/2);t[o]=s+c}},o.prototype._unFilterType4=function(e,t,n){for(var r=this._xComparison,a=r-1,o=this._lastLine,s=0;sa?t[s-r]:0,f=s>a&&o?o[s-r]:0,h=i(c,l,f);t[s]=u+h}},o.prototype._reverseFilterLine=function(e){var t,r=e[0],i=this._images[this._imageIndex],a=i.byteWidth;if(0===r)t=e.slice(1,a+1);else switch(t=new n(a),r){case 1:this._unFilterType1(e,t,a);break;case 2:this._unFilterType2(e,t,a);break;case 3:this._unFilterType3(e,t,a);break;case 4:this._unFilterType4(e,t,a);break;default:throw new Error("Unrecognised filter type - "+r)}this.write(t),i.lineIndex++,i.lineIndex>=i.height?(this._lastLine=null,this._imageIndex++,i=this._images[this._imageIndex]):this._lastLine=t,i?this.read(i.byteWidth+1,this._reverseFilterLine.bind(this)):(this._lastLine=null,this.complete())}}).call(this,e("buffer").Buffer)},{"./interlace":86,"./paeth-predictor":90,buffer:4}],85:[function(e,t,n){(function(e){"use strict";t.exports=function(t,n){var r=n.depth,i=n.width,a=n.height,o=n.colorType,s=n.transColor,u=n.palette,l=t;return 3===o?function(e,t,n,r,i){for(var a=0,o=0;o0&&f>0&&n.push({width:c,height:f,index:u})}return n},n.getInterlaceIterator=function(e){return function(t,n,i){var a=t%r[i].x.length,o=(t-a)/r[i].x.length*8+r[i].x[a],s=n%r[i].y.length;return 4*o+((n-s)/r[i].y.length*8+r[i].y[s])*e*4}}},{}],87:[function(e,t,n){(function(n){"use strict";var r=e("util"),i=e("stream"),a=e("./constants"),o=e("./packer"),s=t.exports=function(e){i.call(this);var t=e||{};this._packer=new o(t),this._deflate=this._packer.createDeflate(),this.readable=!0};r.inherits(s,i),s.prototype.pack=function(e,t,r,i){this.emit("data",new n(a.PNG_SIGNATURE)),this.emit("data",this._packer.packIHDR(t,r)),i&&this.emit("data",this._packer.packGAMA(i));var o=this._packer.filterData(e,t,r);this._deflate.on("error",this.emit.bind(this,"error")),this._deflate.on("data",function(e){this.emit("data",this._packer.packIDAT(e))}.bind(this)),this._deflate.on("end",function(){this.emit("data",this._packer.packIEND()),this.emit("end")}.bind(this)),this._deflate.end(o)}}).call(this,e("buffer").Buffer)},{"./constants":79,"./packer":89,buffer:4,stream:112,util:135}],88:[function(e,t,n){(function(n){"use strict";var r=!0,i=e("zlib");i.deflateSync||(r=!1);var a=e("./constants"),o=e("./packer");t.exports=function(e,t){if(!r)throw new Error("To use the sync capability of this library in old node versions, please also add a dependency on node-zlb-backport");var s=new o(t||{}),u=[];u.push(new n(a.PNG_SIGNATURE)),u.push(s.packIHDR(e.width,e.height)),e.gamma&&u.push(s.packGAMA(e.gamma));var l=s.filterData(e.data,e.width,e.height),c=i.deflateSync(l,s.getDeflateOptions());if(l=null,!c||!c.length)throw new Error("bad png - invalid compressed data response");return u.push(s.packIDAT(c)),u.push(s.packIEND()),n.concat(u)}}).call(this,e("buffer").Buffer)},{"./constants":79,"./packer":89,buffer:4,zlib:41}],89:[function(e,t,n){(function(n){"use strict";var r=e("./constants"),i=e("./crc"),a=e("./bitpacker"),o=e("./filter-pack"),s=e("zlib"),u=t.exports=function(e){if(this._options=e,e.deflateChunkSize=e.deflateChunkSize||32768,e.deflateLevel=null!=e.deflateLevel?e.deflateLevel:9,e.deflateStrategy=null!=e.deflateStrategy?e.deflateStrategy:3,e.inputHasAlpha=null==e.inputHasAlpha||e.inputHasAlpha,e.deflateFactory=e.deflateFactory||s.createDeflate,e.bitDepth=e.bitDepth||8,e.colorType="number"==typeof e.colorType?e.colorType:r.COLORTYPE_COLOR_ALPHA,e.colorType!==r.COLORTYPE_COLOR&&e.colorType!==r.COLORTYPE_COLOR_ALPHA)throw new Error("option color type:"+e.colorType+" is not supported at present");if(8!==e.bitDepth)throw new Error("option bit depth:"+e.bitDepth+" is not supported at present")};u.prototype.getDeflateOptions=function(){return{chunkSize:this._options.deflateChunkSize,level:this._options.deflateLevel,strategy:this._options.deflateStrategy}},u.prototype.createDeflate=function(){return this._options.deflateFactory(this.getDeflateOptions())},u.prototype.filterData=function(e,t,n){var i=a(e,t,n,this._options),s=r.COLORTYPE_TO_BPP_MAP[this._options.colorType];return o(i,t,n,this._options,s)},u.prototype._packChunk=function(e,t){var r=t?t.length:0,a=new n(r+12);return a.writeUInt32BE(r,0),a.writeUInt32BE(e,4),t&&t.copy(a,8),a.writeInt32BE(i.crc32(a.slice(4,a.length-4)),a.length-4),a},u.prototype.packGAMA=function(e){var t=new n(4);return t.writeUInt32BE(Math.floor(e*r.GAMMA_DIVISION),0),this._packChunk(r.TYPE_gAMA,t)},u.prototype.packIHDR=function(e,t){var i=new n(13);return i.writeUInt32BE(e,0),i.writeUInt32BE(t,4),i[8]=this._options.bitDepth,i[9]=this._options.colorType,i[10]=0,i[11]=0,i[12]=0,this._packChunk(r.TYPE_IHDR,i)},u.prototype.packIDAT=function(e){return this._packChunk(r.TYPE_IDAT,e)},u.prototype.packIEND=function(){return this._packChunk(r.TYPE_IEND,null)}}).call(this,e("buffer").Buffer)},{"./bitpacker":77,"./constants":79,"./crc":80,"./filter-pack":81,buffer:4,zlib:41}],90:[function(e,t,n){"use strict";t.exports=function(e,t,n){var r=e+t-n,i=Math.abs(r-e),a=Math.abs(r-t),o=Math.abs(r-n);return i<=a&&i<=o?e:a<=o?t:n}},{}],91:[function(e,t,n){"use strict";var r=e("util"),i=e("zlib"),a=e("./chunkstream"),o=e("./filter-parse-async"),s=e("./parser"),u=e("./bitmapper"),l=e("./format-normaliser"),c=t.exports=function(e){a.call(this),this._parser=new s(e,{read:this.read.bind(this),error:this._handleError.bind(this),metadata:this._handleMetaData.bind(this),gamma:this.emit.bind(this,"gamma"),palette:this._handlePalette.bind(this),transColor:this._handleTransColor.bind(this),finished:this._finished.bind(this),inflateData:this._inflateData.bind(this)}),this._options=e,this.writable=!0,this._parser.start()};r.inherits(c,a),c.prototype._handleError=function(e){this.emit("error",e),this.writable=!1,this.destroy(),this._inflate&&this._inflate.destroy&&this._inflate.destroy(),this.errord=!0},c.prototype._inflateData=function(e){this._inflate||(this._inflate=i.createInflate(),this._inflate.on("error",this.emit.bind(this,"error")),this._filter.on("complete",this._complete.bind(this)),this._inflate.pipe(this._filter)),this._inflate.write(e)},c.prototype._handleMetaData=function(e){this.emit("metadata",e),this._bitmapInfo=Object.create(e),this._filter=new o(this._bitmapInfo)},c.prototype._handleTransColor=function(e){this._bitmapInfo.transColor=e},c.prototype._handlePalette=function(e){this._bitmapInfo.palette=e},c.prototype._finished=function(){this.errord||(this._inflate?this._inflate.end():this.emit("error","No Inflate block"),this.destroySoon())},c.prototype._complete=function(e){if(!this.errord){try{var t=u.dataToBitMap(e,this._bitmapInfo),n=l(t,this._bitmapInfo);t=null}catch(e){return void this._handleError(e)}this.emit("parsed",n)}}},{"./bitmapper":76,"./chunkstream":78,"./filter-parse-async":82,"./format-normaliser":85,"./parser":93,util:135,zlib:41}],92:[function(e,t,n){(function(n){"use strict";var r=!0,i=e("zlib");i.deflateSync||(r=!1);var a=e("./sync-reader"),o=e("./filter-parse-sync"),s=e("./parser"),u=e("./bitmapper"),l=e("./format-normaliser");t.exports=function(e,t){if(!r)throw new Error("To use the sync capability of this library in old node versions, please also add a dependency on node-zlb-backport");var c,f,h;var p=[];var d=new a(e);if(new s(t,{read:d.read.bind(d),error:function(e){c=e},metadata:function(e){f=e},gamma:function(e){h=e},palette:function(e){f.palette=e},transColor:function(e){f.transColor=e},inflateData:function(e){p.push(e)}}).start(),d.process(),c)throw c;var g=n.concat(p);p.length=0;var v=i.inflateSync(g);if(g=null,!v||!v.length)throw new Error("bad png - invalid inflate data response");var m=o.process(v,f);g=null;var _=u.dataToBitMap(m,f);m=null;var w=l(_,f);return f.data=w,f.gamma=h||0,f}}).call(this,e("buffer").Buffer)},{"./bitmapper":76,"./filter-parse-sync":83,"./format-normaliser":85,"./parser":93,"./sync-reader":96,buffer:4,zlib:41}],93:[function(e,t,n){(function(n){"use strict";var r=e("./constants"),i=e("./crc"),a=t.exports=function(e,t){this._options=e,e.checkCRC=!1!==e.checkCRC,this._hasIHDR=!1,this._hasIEND=!1,this._palette=[],this._colorType=0,this._chunks={},this._chunks[r.TYPE_IHDR]=this._handleIHDR.bind(this),this._chunks[r.TYPE_IEND]=this._handleIEND.bind(this),this._chunks[r.TYPE_IDAT]=this._handleIDAT.bind(this),this._chunks[r.TYPE_PLTE]=this._handlePLTE.bind(this),this._chunks[r.TYPE_tRNS]=this._handleTRNS.bind(this),this._chunks[r.TYPE_gAMA]=this._handleGAMA.bind(this),this.read=t.read,this.error=t.error,this.metadata=t.metadata,this.gamma=t.gamma,this.transColor=t.transColor,this.palette=t.palette,this.parsed=t.parsed,this.inflateData=t.inflateData,this.inflateData=t.inflateData,this.finished=t.finished};a.prototype.start=function(){this.read(r.PNG_SIGNATURE.length,this._parseSignature.bind(this))},a.prototype._parseSignature=function(e){for(var t=r.PNG_SIGNATURE,n=0;nthis._palette.length)return void this.error(new Error("More transparent colors than palette size"));for(var t=0;t0?this._handleIDAT(n):this._handleChunkEnd()},a.prototype._handleIEND=function(e){this.read(e,this._parseIEND.bind(this))},a.prototype._parseIEND=function(e){this._crc.write(e),this._hasIEND=!0,this._handleChunkEnd(),this.finished&&this.finished()}}).call(this,e("buffer").Buffer)},{"./constants":79,"./crc":80,buffer:4}],94:[function(e,t,n){"use strict";var r=e("./parser-sync"),i=e("./packer-sync");n.read=function(e,t){return r(e,t||{})},n.write=function(e){return i(e)}},{"./packer-sync":88,"./parser-sync":92}],95:[function(e,t,n){(function(t,r){"use strict";var i=e("util"),a=e("stream"),o=e("./parser-async"),s=e("./packer-async"),u=e("./png-sync"),l=n.PNG=function(e){a.call(this),e=e||{},this.width=e.width||0,this.height=e.height||0,this.data=this.width>0&&this.height>0?new r(4*this.width*this.height):null,e.fill&&this.data&&this.data.fill(0),this.gamma=0,this.readable=this.writable=!0,this._parser=new o(e),this._parser.on("error",this.emit.bind(this,"error")),this._parser.on("close",this._handleClose.bind(this)),this._parser.on("metadata",this._metadata.bind(this)),this._parser.on("gamma",this._gamma.bind(this)),this._parser.on("parsed",function(e){this.data=e,this.emit("parsed",e)}.bind(this)),this._packer=new s(e),this._packer.on("data",this.emit.bind(this,"data")),this._packer.on("end",this.emit.bind(this,"end")),this._parser.on("close",this._handleClose.bind(this)),this._packer.on("error",this.emit.bind(this,"error"))};i.inherits(l,a),l.sync=u,l.prototype.pack=function(){return this.data&&this.data.length?(t.nextTick(function(){this._packer.pack(this.data,this.width,this.height,this.gamma)}.bind(this)),this):(this.emit("error","No data provided"),this)},l.prototype.parse=function(e,t){var n,r;t&&(n=function(e){this.removeListener("error",r),this.data=e,t(null,this)}.bind(this),r=function(e){this.removeListener("parsed",n),t(e,null)}.bind(this),this.once("parsed",n),this.once("error",r));return this.end(e),this},l.prototype.write=function(e){return this._parser.write(e),!0},l.prototype.end=function(e){this._parser.end(e)},l.prototype._metadata=function(e){this.width=e.width,this.height=e.height,this.emit("metadata",e)},l.prototype._gamma=function(e){this.gamma=e},l.prototype._handleClose=function(){this._parser.writable||this._packer.readable||this.emit("close")},l.bitblt=function(e,t,n,r,i,a,o,s){if(n>e.width||r>e.height||n+i>e.width||r+a>e.height)throw new Error("bitblt reading outside image");if(o>t.width||s>t.height||o+i>t.width||s+a>t.height)throw new Error("bitblt writing outside image");for(var u=0;u0&&this._buffer.length;){var e=this._reads[0];if(!this._buffer.length||!(this._buffer.length>=e.length||e.allowLess))break;this._reads.shift();var t=this._buffer;this._buffer=t.slice(e.length),e.func.call(this,t.slice(0,e.length))}return this._reads.length>0?new Error("There are some read requests waitng on finished stream"):this._buffer.length>0?new Error("unrecognised content at end of stream"):void 0}},{}],97:[function(e,t,n){(function(e){"use strict";!e.version||0===e.version.indexOf("v0.")||0===e.version.indexOf("v1.")&&0!==e.version.indexOf("v1.8.")?t.exports={nextTick:function(t,n,r,i){if("function"!=typeof t)throw new TypeError('"callback" argument must be a function');var a,o,s=arguments.length;switch(s){case 0:case 1:return e.nextTick(t);case 2:return e.nextTick(function(){t.call(null,n)});case 3:return e.nextTick(function(){t.call(null,n,r)});case 4:return e.nextTick(function(){t.call(null,n,r,i)});default:for(a=new Array(s-1),o=0;o1)for(var n=1;n0?d(e):b(e)}(e,t);else if(t.objectMode||r&&r.length>0)if(t.ended&&!o){var u=new Error("stream.push() after EOF");e.emit("error",u)}else if(t.endEmitted&&o){u=new Error("stream.unshift() after end event");e.emit("error",u)}else!t.decoder||o||a||(r=t.decoder.write(r)),t.length+=t.objectMode?1:r.length,o?t.buffer.unshift(r):(t.reading=!1,t.buffer.push(r)),t.needReadable&&d(e),function(e,t){t.readingMore||(t.readingMore=!0,n.nextTick(function(){!function(e,t){var n=t.length;for(;!t.reading&&!t.flowing&&!t.ended&&t.lengtht.highWaterMark&&(t.highWaterMark=function(e){if(e>=h)e=h;else{e--;for(var t=1;t<32;t<<=1)e|=e>>t;e++}return e}(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function d(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?n.nextTick(function(){g(e)}):g(e))}function g(e){e.emit("readable")}function v(e){var t,n=e._readableState;function r(e,r,i){!1===e.write(t)&&n.awaitDrain++}for(n.awaitDrain=0;n.pipesCount&&null!==(t=e.read());)if(1===n.pipesCount?r(n.pipes):y(n.pipes,r),e.emit("data",t),n.awaitDrain>0)return;if(0===n.pipesCount)return n.flowing=!1,void(a.listenerCount(e,"data")>0&&_(e));n.ranOut=!0}function m(){this._readableState.ranOut&&(this._readableState.ranOut=!1,v(this))}function _(e,t){if(e._readableState.flowing)throw new Error("Cannot switch to old mode now.");var r=t||!1,i=!1;e.readable=!0,e.pipe=s.prototype.pipe,e.on=e.addListener=s.prototype.on,e.on("readable",function(){var t;for(i=!0;!r&&null!==(t=e.read());)e.emit("data",t);null===t&&(i=!1,e._readableState.needReadable=!0)}),e.pause=function(){r=!0,this.emit("pause")},e.resume=function(){r=!1,i?n.nextTick(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function w(e,t){var n,r=t.buffer,a=t.length,o=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===a)n=null;else if(s)n=r.shift();else if(!e||e>=a)n=o?r.join(""):i.concat(r,a),r.length=0;else{if(e0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,n.nextTick(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function y(e,t){for(var n=0,r=e.length;n0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return d(this),null;if(0===(e=p(e,t))&&t.ended)return n=null,t.length>0&&t.decoder&&(n=w(e,t),t.length-=n.length),0===t.length&&b(this),n;var i=t.needReadable;return t.length-e<=t.highWaterMark&&(i=!0),(t.ended||t.reading)&&(i=!1),i&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),i&&!t.reading&&(e=p(r,t)),null===(n=e>0?w(e,t):null)&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&b(this),n},c.prototype._read=function(e){this.emit("error",new Error("not implemented"))},c.prototype.pipe=function(e,t){var i=this,o=this._readableState;switch(o.pipesCount){case 0:o.pipes=e;break;case 1:o.pipes=[o.pipes,e];break;default:o.pipes.push(e)}o.pipesCount+=1;var s=(!t||!1!==t.end)&&e!==n.stdout&&e!==n.stderr?l:f;function u(e){e===i&&f()}function l(){e.end()}o.endEmitted?n.nextTick(s):i.once("end",s),e.on("unpipe",u);var c=function(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&v(e)}}(i);function f(){e.removeListener("close",p),e.removeListener("finish",d),e.removeListener("drain",c),e.removeListener("error",h),e.removeListener("unpipe",u),i.removeListener("end",l),i.removeListener("end",f),e._writableState&&!e._writableState.needDrain||c()}function h(t){g(),e.removeListener("error",h),0===a.listenerCount(e,"error")&&e.emit("error",t)}function p(){e.removeListener("finish",d),g()}function d(){e.removeListener("close",p),g()}function g(){i.unpipe(e)}return e.on("drain",c),e._events&&e._events.error?r(e._events.error)?e._events.error.unshift(h):e._events.error=[h,e._events.error]:e.on("error",h),e.once("close",p),e.once("finish",d),e.emit("pipe",i),o.flowing||(this.on("readable",m),o.flowing=!0,n.nextTick(function(){v(i)})),e},c.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",m),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",m),t.flowing=!1;for(var i=0;i0&&!e[o-1];)o--;a.push({children:[],index:0});var s,u=a[0];for(n=0;n0;)u=a.pop();for(u.index++,a.push(u);a.length<=n;)a.push(s={children:[],index:0}),u.children[u.index]=s.children,u=s;i++}n+10)return p>>--d&1;if(255==(p=t[n++])){var e=t[n++];if(e)throw"unexpected marker: "+(p<<8|e).toString(16)}return d=7,p>>>7}function v(e){for(var t,n=e;null!==(t=g());){if("number"==typeof(n=n[t]))return n;if("object"!=typeof n)throw"invalid huffman sequence"}return null}function m(e){for(var t=0;e>0;){var n=g();if(null===n)return;t=t<<1|n,e--}return t}function _(e){var t=m(e);return t>=1<0)w--;else for(var r=o,i=s;r<=i;){var a=v(t.huffmanTableAC),u=15&a,c=a>>4;if(0!==u)n[e[r+=c]]=_(u)*(1<>4,0===f)a<15?(w=m(a)+(1<>4;if(0!==s)n[e[a+=u]]=_(s),a++;else{if(u<15)break;a+=16}}};var R,C,B,L,O=0;for(C=1==I?i[0].blocksPerLine*i[0].blocksPerColumn:c*r.mcusPerColumn,a||(a=C);O=65488&&R<=65495))break;n+=2}return n-h}function h(e,l){var c,f,h=[],p=l.blocksPerLine,d=l.blocksPerColumn,g=p<<3,v=new Int32Array(64),m=new Uint8Array(64);function _(e,c,f){var h,p,d,g,v,m,_,w,b,y,x=l.quantizationTable,k=f;for(y=0;y<64;y++)k[y]=e[y]*x[y];for(y=0;y<8;++y){var E=8*y;0!=k[1+E]||0!=k[2+E]||0!=k[3+E]||0!=k[4+E]||0!=k[5+E]||0!=k[6+E]||0!=k[7+E]?(h=s*k[0+E]+128>>8,p=s*k[4+E]+128>>8,d=k[2+E],g=k[6+E],v=u*(k[1+E]-k[7+E])+128>>8,w=u*(k[1+E]+k[7+E])+128>>8,m=k[3+E]<<4,_=k[5+E]<<4,b=h-p+1>>1,h=h+p+1>>1,p=b,b=d*o+g*a+128>>8,d=d*a-g*o+128>>8,g=b,b=v-_+1>>1,v=v+_+1>>1,_=b,b=w+m+1>>1,m=w-m+1>>1,w=b,b=h-g+1>>1,h=h+g+1>>1,g=b,b=p-d+1>>1,p=p+d+1>>1,d=b,b=v*i+w*r+2048>>12,v=v*r-w*i+2048>>12,w=b,b=m*n+_*t+2048>>12,m=m*t-_*n+2048>>12,_=b,k[0+E]=h+w,k[7+E]=h-w,k[1+E]=p+_,k[6+E]=p-_,k[2+E]=d+m,k[5+E]=d-m,k[3+E]=g+v,k[4+E]=g-v):(b=s*k[0+E]+512>>10,k[0+E]=b,k[1+E]=b,k[2+E]=b,k[3+E]=b,k[4+E]=b,k[5+E]=b,k[6+E]=b,k[7+E]=b)}for(y=0;y<8;++y){var S=y;0!=k[8+S]||0!=k[16+S]||0!=k[24+S]||0!=k[32+S]||0!=k[40+S]||0!=k[48+S]||0!=k[56+S]?(h=s*k[0+S]+2048>>12,p=s*k[32+S]+2048>>12,d=k[16+S],g=k[48+S],v=u*(k[8+S]-k[56+S])+2048>>12,w=u*(k[8+S]+k[56+S])+2048>>12,m=k[24+S],_=k[40+S],b=h-p+1>>1,h=h+p+1>>1,p=b,b=d*o+g*a+2048>>12,d=d*a-g*o+2048>>12,g=b,b=v-_+1>>1,v=v+_+1>>1,_=b,b=w+m+1>>1,m=w-m+1>>1,w=b,b=h-g+1>>1,h=h+g+1>>1,g=b,b=p-d+1>>1,p=p+d+1>>1,d=b,b=v*i+w*r+2048>>12,v=v*r-w*i+2048>>12,w=b,b=m*n+_*t+2048>>12,m=m*t-_*n+2048>>12,_=b,k[0+S]=h+w,k[56+S]=h-w,k[8+S]=p+_,k[48+S]=p-_,k[16+S]=d+m,k[40+S]=d-m,k[24+S]=g+v,k[32+S]=g-v):(b=s*f[y+0]+8192>>14,k[0+S]=b,k[8+S]=b,k[16+S]=b,k[24+S]=b,k[32+S]=b,k[40+S]=b,k[48+S]=b,k[56+S]=b)}for(y=0;y<64;++y){var A=128+(k[y]+8>>4);c[y]=A<0?0:A>255?255:A}}for(var w=0;w255?255:e}return l.prototype={load:function(e){var t=new XMLHttpRequest;t.open("GET",e,!0),t.responseType="arraybuffer",t.onload=function(){var e=new Uint8Array(t.response||t.mozResponseArrayBuffer);this.parse(e),this.onload&&this.onload()}.bind(this),t.send(null)},parse:function(t){var n=0;t.length;function r(){var e=t[n]<<8|t[n+1];return n+=2,e}function i(){var e=r(),i=t.subarray(n,n+e-2);return n+=i.length,i}function a(e){var t,n,r=0,i=0;for(n in e.components)e.components.hasOwnProperty(n)&&(r<(t=e.components[n]).h&&(r=t.h),i>4==0)for(_=0;_<64;_++){x[e[_]]=t[n++]}else{if(y>>4!=1)throw"DQT: invalid table spec";for(_=0;_<64;_++){x[e[_]]=r()}}p[15&y]=x}break;case 65472:case 65473:case 65474:r(),(o={}).extended=65473===m,o.progressive=65474===m,o.precision=t[n++],o.scanLines=r(),o.samplesPerLine=r(),o.components={},o.componentsOrder=[];var k,E=t[n++];for(P=0;P>4,A=15&t[n+1],M=t[n+2];o.componentsOrder.push(k),o.components[k]={h:S,v:A,quantizationTable:p[M]},n+=3}a(o),d.push(o);break;case 65476:var T=r();for(P=2;P>4==0?v:g)[15&j]=c(I,C)}break;case 65501:r(),s=r();break;case 65498:r();var B=t[n++],L=[];for(P=0;P>4],U.huffmanTableAC=g[15&O],L.push(U)}var z=t[n++],D=t[n++],F=t[n++],N=f(t,n,o,L,s,z,D,F>>4,15&F);n+=N;break;default:if(255==t[n-3]&&t[n-2]>=192&&t[n-2]<=254){n-=3;break}throw"unknown JPEG marker "+m.toString(16)}m=r()}if(1!=d.length)throw"only single frame JPEGs supported";this.width=o.samplesPerLine,this.height=o.scanLines,this.jfif=u,this.adobe=l,this.components=[];for(var P=0;P=0;)t&1<>8&255),O(255&e)}function D(e,t,n,r,i){var a,o=i[0],s=i[240];for(var u=function(e,t){var n,r,i,a,o,s,u,l,c,f,h=0;for(c=0;c<8;++c){n=e[h],r=e[h+1],i=e[h+2],a=e[h+3],o=e[h+4],s=e[h+5],u=e[h+6];var p=n+(l=e[h+7]),g=n-l,v=r+u,m=r-u,_=i+s,w=i-s,b=a+o,y=a-o,x=p+b,k=p-b,E=v+_,S=v-_;e[h]=x+E,e[h+4]=x-E;var A=.707106781*(S+k);e[h+2]=k+A,e[h+6]=k-A;var M=.382683433*((x=y+w)-(S=m+g)),T=.5411961*x+M,j=1.306562965*S+M,I=.707106781*(E=w+m),R=g+I,C=g-I;e[h+5]=C+T,e[h+3]=C-T,e[h+1]=R+j,e[h+7]=R-j,h+=8}for(h=0,c=0;c<8;++c){n=e[h],r=e[h+8],i=e[h+16],a=e[h+24],o=e[h+32],s=e[h+40],u=e[h+48];var B=n+(l=e[h+56]),L=n-l,O=r+u,z=r-u,D=i+s,F=i-s,N=a+o,P=a-o,U=B+N,q=B-N,V=O+D,Z=O-D;e[h]=U+V,e[h+32]=U-V;var W=.707106781*(Z+q);e[h+16]=q+W,e[h+48]=q-W;var G=.382683433*((U=P+F)-(Z=z+L)),H=.5411961*U+G,Y=1.306562965*Z+G,$=.707106781*(V=F+z),X=L+$,J=L-$;e[h+40]=J+H,e[h+24]=J-H,e[h+8]=X+Y,e[h+56]=X-Y,h++}for(c=0;c<64;++c)f=e[c]*t[c],d[c]=f>0?f+.5|0:f-.5|0;return d}(e,t),l=0;l<64;++l)g[E[l]]=u[l];var c=g[0]-n;n=g[0],0==c?L(r[0]):(L(r[p[a=32767+c]]),L(h[a]));for(var f=63;f>0&&0==g[f];f--);if(0==f)return L(o),n;for(var v,m=1;m<=f;){for(var _=m;0==g[m]&&m<=f;++m);var w=m-_;if(w>=16){v=w>>4;for(var b=1;b<=v;++b)L(s);w&=15}a=32767+g[m],L(i[(w<<4)+p[a]]),L(h[a]),m++}return 63!=f&&L(o),n}function F(e){if(e<=0&&(e=1),e>100&&(e=100),o!=e){(function(e){for(var t=[16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99],n=0;n<64;n++){var r=s((t[n]*e+50)/100);r<1?r=1:r>255&&(r=255),u[E[n]]=r}for(var i=[17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99],a=0;a<64;a++){var o=s((i[a]*e+50)/100);o<1?o=1:o>255&&(o=255),l[E[a]]=o}for(var h=[1,1.387039845,1.306562965,1.175875602,1,.785694958,.5411961,.275899379],p=0,d=0;d<8;d++)for(var g=0;g<8;g++)c[p]=1/(u[E[p]]*h[d]*h[g]*8),f[p]=1/(l[E[p]]*h[d]*h[g]*8),p++})(e<50?Math.floor(5e3/e):Math.floor(200-2*e)),o=e}}this.encode=function(t,o){(new Date).getTime();o&&F(o),v=new Array,m=0,_=7,z(65496),z(65504),z(16),O(74),O(70),O(73),O(70),O(0),O(1),O(1),O(0),z(1),z(1),O(0),O(0),function(){z(65499),z(132),O(0);for(var e=0;e<64;e++)O(u[e]);O(1);for(var t=0;t<64;t++)O(l[t])}(),function(e,t){z(65472),z(17),O(8),z(t),z(e),O(3),O(1),O(17),O(0),O(2),O(17),O(1),O(3),O(17),O(1)}(t.width,t.height),function(){z(65476),z(418),O(0);for(var e=0;e<16;e++)O(S[e+1]);for(var t=0;t<=11;t++)O(A[t]);O(16);for(var n=0;n<16;n++)O(M[n+1]);for(var r=0;r<=161;r++)O(T[r]);O(1);for(var i=0;i<16;i++)O(j[i+1]);for(var a=0;a<=11;a++)O(I[a]);O(17);for(var o=0;o<16;o++)O(R[o+1]);for(var s=0;s<=161;s++)O(C[s])}(),z(65498),z(12),O(3),O(1),O(0),O(2),O(17),O(3),O(17),O(0),O(63),O(0);var s=0,h=0,p=0;m=0,_=7,this.encode.displayName="_encode_";for(var d,g,x,E,B,N,P,U,q,V=t.data,Z=t.width,W=t.height,G=4*Z,H=0;H>3)*G+(P=4*(7&q)),H+U>=W&&(N-=G*(H+1+U-W)),d+P>=G&&(N-=d+P-G+4),g=V[N++],x=V[N++],E=V[N++],w[q]=(k[g]+k[x+256>>0]+k[E+512>>0]>>16)-128,b[q]=(k[g+768>>0]+k[x+1024>>0]+k[E+1280>>0]>>16)-128,y[q]=(k[g+1280>>0]+k[x+1536>>0]+k[E+1792>>0]>>16)-128;s=D(w,c,s,n,i),h=D(b,f,h,r,a),p=D(y,f,p,r,a),d+=32}H+=8}if(_>=0){var Y=[];Y[1]=_+1,Y[0]=(1<<_+1)-1,L(Y)}return z(65497),new e(v)},function(){(new Date).getTime();t||(t=50),function(){for(var e=String.fromCharCode,t=0;t<256;t++)x[t]=e(t)}(),n=B(S,A),r=B(j,I),i=B(M,T),a=B(R,C),function(){for(var e=1,t=2,n=1;n<=15;n++){for(var r=e;r>0]=38470*e,k[e+512>>0]=7471*e+32768,k[e+768>>0]=-11059*e,k[e+1024>>0]=-21709*e,k[e+1280>>0]=32768*e+8421375,k[e+1536>>0]=-27439*e,k[e+1792>>0]=-5329*e}(),F(t),(new Date).getTime()}()}t.exports=function(e,t){void 0===t&&(t=50);return{data:new n(t).encode(e,t),width:e.width,height:e.height}}}).call(this,e("buffer").Buffer)},{buffer:4}],111:[function(e,t,n){(function(n){"use strict";var r=e("contentstream"),i=e("gif-encoder"),a=e("jpeg-js"),o=e("pngjs-nozlib").PNG,s=e("ndarray"),u=e("ndarray-ops"),l=e("through");function c(e,t,n){if(4===e.shape.length)return c(e.pick(n),t,0);if(3===e.shape.length)if(3===e.shape[2])u.assign(s(t,[e.shape[0],e.shape[1],3],[4,4*e.shape[0],1]),e),u.assigns(s(t,[e.shape[0]*e.shape[1]],[4],3),255);else if(4===e.shape[2])u.assign(s(t,[e.shape[0],e.shape[1],4],[4,4*e.shape[0],1]),e);else{if(1!==e.shape[2])return new Error("Incompatible array shape");u.assign(s(t,[e.shape[0],e.shape[1],3],[4,4*e.shape[0],1]),s(e.data,[e.shape[0],e.shape[1],3],[e.stride[0],e.stride[1],0],e.offset)),u.assigns(s(t,[e.shape[0]*e.shape[1]],[4],3),255)}else{if(2!==e.shape.length)return new Error("Incompatible array shape");u.assign(s(t,[e.shape[0],e.shape[1],3],[4,4*e.shape[0],1]),s(e.data,[e.shape[0],e.shape[1],3],[e.stride[0],e.stride[1],0],e.offset)),u.assigns(s(t,[e.shape[0]*e.shape[1]],[4],3),255)}return t}function f(e){var t=l();return t.emit("error",e),t}t.exports=function(e,t,s){switch(s=s||{},t.toUpperCase()){case"JPG":case".JPG":case"JPEG":case".JPEG":case"JPE":case".JPE":var u=e.shape[0],l=e.shape[1],h={data:g=c(e,g=new n(u*l*4)),width:u,height:l},p=a.encode(h,s.quality);return new r(p.data);case"GIF":case".GIF":var d=4===e.shape.length?e.shape[0]:1,g=(u=4===e.shape.length?e.shape[1]:e.shape[0],l=4===e.shape.length?e.shape[2]:e.shape[1],new n(u*l*4)),v=new i(u,l);v.writeHeader();for(var m=0;m0?("string"==typeof t||o.objectMode||Object.getPrototypeOf(t)===l.prototype||(t=function(e){return l.from(e)}(t)),r?o.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):y(e,o,t,!0):o.ended?e.emit("error",new Error("stream.push() after EOF")):(o.reading=!1,o.decoder&&!n?(t=o.decoder.write(t),o.objectMode||0!==t.length?y(e,o,t,!1):A(e,o)):y(e,o,t,!1))):r||(o.reading=!1));return function(e){return!e.ended&&(e.needReadable||e.lengtht.highWaterMark&&(t.highWaterMark=function(e){return e>=x?e=x:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function E(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(p("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?i.nextTick(S,e):S(e))}function S(e){p("emit readable"),e.emit("readable"),I(e)}function A(e,t){t.readingMore||(t.readingMore=!0,i.nextTick(M,e,t))}function M(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(n=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):n=function(e,t,n){var r;ea.length?a.length:e;if(o===a.length?i+=a:i+=a.slice(0,e),0===(e-=o)){o===a.length?(++r,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n,n.data=a.slice(o));break}++r}return t.length-=r,i}(e,t):function(e,t){var n=l.allocUnsafe(e),r=t.head,i=1;r.data.copy(n),e-=r.data.length;for(;r=r.next;){var a=r.data,o=e>a.length?a.length:e;if(a.copy(n,n.length-e,0,o),0===(e-=o)){o===a.length?(++i,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=a.slice(o));break}++i}return t.length-=i,n}(e,t);return r}(e,t.buffer,t.decoder),n);var n}function C(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,i.nextTick(B,t,e))}function B(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function L(e,t){for(var n=0,r=e.length;n=t.highWaterMark||t.ended))return p("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?C(this):E(this),null;if(0===(e=k(e,t))&&t.ended)return 0===t.length&&C(this),null;var r,i=t.needReadable;return p("need readable",i),(0===t.length||t.length-e0?R(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),n!==e&&t.ended&&C(this)),null!==r&&this.emit("data",r),r},w.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},w.prototype.pipe=function(e,t){var r=this,a=this._readableState;switch(a.pipesCount){case 0:a.pipes=e;break;case 1:a.pipes=[a.pipes,e];break;default:a.pipes.push(e)}a.pipesCount+=1,p("pipe count=%d opts=%j",a.pipesCount,t);var u=(!t||!1!==t.end)&&e!==n.stdout&&e!==n.stderr?c:w;function l(t,n){p("onunpipe"),t===r&&n&&!1===n.hasUnpiped&&(n.hasUnpiped=!0,p("cleanup"),e.removeListener("close",m),e.removeListener("finish",_),e.removeListener("drain",f),e.removeListener("error",v),e.removeListener("unpipe",l),r.removeListener("end",c),r.removeListener("end",w),r.removeListener("data",g),h=!0,!a.awaitDrain||e._writableState&&!e._writableState.needDrain||f())}function c(){p("onend"),e.end()}a.endEmitted?i.nextTick(u):r.once("end",u),e.on("unpipe",l);var f=function(e){return function(){var t=e._readableState;p("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&s(e,"data")&&(t.flowing=!0,I(e))}}(r);e.on("drain",f);var h=!1;var d=!1;function g(t){p("ondata"),d=!1,!1!==e.write(t)||d||((1===a.pipesCount&&a.pipes===e||a.pipesCount>1&&-1!==L(a.pipes,e))&&!h&&(p("false write response, pause",r._readableState.awaitDrain),r._readableState.awaitDrain++,d=!0),r.pause())}function v(t){p("onerror",t),w(),e.removeListener("error",v),0===s(e,"error")&&e.emit("error",t)}function m(){e.removeListener("finish",_),w()}function _(){p("onfinish"),e.removeListener("close",m),w()}function w(){p("unpipe"),r.unpipe(e)}return r.on("data",g),function(e,t,n){if("function"==typeof e.prependListener)return e.prependListener(t,n);e._events&&e._events[t]?o(e._events[t])?e._events[t].unshift(n):e._events[t]=[n,e._events[t]]:e.on(t,n)}(e,"error",v),e.once("close",m),e.once("finish",_),e.emit("pipe",r),a.flowing||(p("pipe resume"),r.resume()),e},w.prototype.unpipe=function(e){var t=this._readableState,n={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,n),this);if(!e){var r=t.pipes,i=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var a=0;a-1?i:a.nextTick;_.WritableState=m;var l=e("core-util-is");l.inherits=e("inherits");var c={deprecate:e("util-deprecate")},f=e("./internal/streams/stream"),h=e("safe-buffer").Buffer,p=r.Uint8Array||function(){};var d,g=e("./internal/streams/destroy");function v(){}function m(t,n){s=s||e("./_stream_duplex"),t=t||{};var r=n instanceof s;this.objectMode=!!t.objectMode,r&&(this.objectMode=this.objectMode||!!t.writableObjectMode);var i=t.highWaterMark,l=t.writableHighWaterMark,c=this.objectMode?16:16384;this.highWaterMark=i||0===i?i:r&&(l||0===l)?l:c,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var f=!1===t.decodeStrings;this.decodeStrings=!f,this.defaultEncoding=t.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var n=e._writableState,r=n.sync,i=n.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(n),t)!function(e,t,n,r,i){--t.pendingcb,n?(a.nextTick(i,r),a.nextTick(E,e,t),e._writableState.errorEmitted=!0,e.emit("error",r)):(i(r),e._writableState.errorEmitted=!0,e.emit("error",r),E(e,t))}(e,n,r,t,i);else{var o=x(n);o||n.corked||n.bufferProcessing||!n.bufferedRequest||y(e,n),r?u(b,e,n,o,i):b(e,n,o,i)}}(n,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new o(this)}function _(t){if(s=s||e("./_stream_duplex"),!(d.call(_,this)||this instanceof s))return new _(t);this._writableState=new m(t,this),this.writable=!0,t&&("function"==typeof t.write&&(this._write=t.write),"function"==typeof t.writev&&(this._writev=t.writev),"function"==typeof t.destroy&&(this._destroy=t.destroy),"function"==typeof t.final&&(this._final=t.final)),f.call(this)}function w(e,t,n,r,i,a,o){t.writelen=r,t.writecb=o,t.writing=!0,t.sync=!0,n?e._writev(i,t.onwrite):e._write(i,a,t.onwrite),t.sync=!1}function b(e,t,n,r){n||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,r(),E(e,t)}function y(e,t){t.bufferProcessing=!0;var n=t.bufferedRequest;if(e._writev&&n&&n.next){var r=t.bufferedRequestCount,i=new Array(r),a=t.corkedRequestsFree;a.entry=n;for(var s=0,u=!0;n;)i[s]=n,n.isBuf||(u=!1),n=n.next,s+=1;i.allBuffers=u,w(e,t,!0,t.length,i,"",a.finish),t.pendingcb++,t.lastBufferedRequest=null,a.next?(t.corkedRequestsFree=a.next,a.next=null):t.corkedRequestsFree=new o(t),t.bufferedRequestCount=0}else{for(;n;){var l=n.chunk,c=n.encoding,f=n.callback;if(w(e,t,!1,t.objectMode?1:l.length,l,c,f),n=n.next,t.bufferedRequestCount--,t.writing)break}null===n&&(t.lastBufferedRequest=null)}t.bufferedRequest=n,t.bufferProcessing=!1}function x(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function k(e,t){e._final(function(n){t.pendingcb--,n&&e.emit("error",n),t.prefinished=!0,e.emit("prefinish"),E(e,t)})}function E(e,t){var n=x(t);return n&&(!function(e,t){t.prefinished||t.finalCalled||("function"==typeof e._final?(t.pendingcb++,t.finalCalled=!0,a.nextTick(k,e,t)):(t.prefinished=!0,e.emit("prefinish")))}(e,t),0===t.pendingcb&&(t.finished=!0,e.emit("finish"))),n}l.inherits(_,f),m.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(m.prototype,"buffer",{get:c.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}(),"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(d=Function.prototype[Symbol.hasInstance],Object.defineProperty(_,Symbol.hasInstance,{value:function(e){return!!d.call(this,e)||this===_&&(e&&e._writableState instanceof m)}})):d=function(e){return e instanceof this},_.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},_.prototype.write=function(e,t,n){var r,i=this._writableState,o=!1,s=!i.objectMode&&(r=e,h.isBuffer(r)||r instanceof p);return s&&!h.isBuffer(e)&&(e=function(e){return h.from(e)}(e)),"function"==typeof t&&(n=t,t=null),s?t="buffer":t||(t=i.defaultEncoding),"function"!=typeof n&&(n=v),i.ended?function(e,t){var n=new Error("write after end");e.emit("error",n),a.nextTick(t,n)}(this,n):(s||function(e,t,n,r){var i=!0,o=!1;return null===n?o=new TypeError("May not write null values to stream"):"string"==typeof n||void 0===n||t.objectMode||(o=new TypeError("Invalid non-string/buffer chunk")),o&&(e.emit("error",o),a.nextTick(r,o),i=!1),i}(this,i,e,n))&&(i.pendingcb++,o=function(e,t,n,r,i,a){if(!n){var o=function(e,t,n){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=h.from(t,n));return t}(t,r,i);r!==o&&(n=!0,i="buffer",r=o)}var s=t.objectMode?1:r.length;t.length+=s;var u=t.length-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Object.defineProperty(_.prototype,"writableHighWaterMark",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),_.prototype._write=function(e,t,n){n(new Error("_write() is not implemented"))},_.prototype._writev=null,_.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),null!==e&&void 0!==e&&this.write(e,t),r.corked&&(r.corked=1,this.uncork()),r.ending||r.finished||function(e,t,n){t.ending=!0,E(e,t),n&&(t.finished?a.nextTick(n):e.once("finish",n));t.ended=!0,e.writable=!1}(this,r,n)},Object.defineProperty(_.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),_.prototype.destroy=g.destroy,_.prototype._undestroy=g.undestroy,_.prototype._destroy=function(e,t){this.end(),t(e)}}).call(this,e("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("timers").setImmediate)},{"./_stream_duplex":114,"./internal/streams/destroy":120,"./internal/streams/stream":121,_process:98,"core-util-is":8,inherits:57,"process-nextick-args":97,"safe-buffer":107,timers:128,"util-deprecate":133}],119:[function(e,t,n){"use strict";var r=e("safe-buffer").Buffer,i=e("util");t.exports=function(){function e(){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.head=null,this.tail=null,this.length=0}return e.prototype.push=function(e){var t={data:e,next:null};this.length>0?this.tail.next=t:this.head=t,this.tail=t,++this.length},e.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},e.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},e.prototype.clear=function(){this.head=this.tail=null,this.length=0},e.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,n=""+t.data;t=t.next;)n+=e+t.data;return n},e.prototype.concat=function(e){if(0===this.length)return r.alloc(0);if(1===this.length)return this.head.data;for(var t,n,i,a=r.allocUnsafe(e>>>0),o=this.head,s=0;o;)t=o.data,n=a,i=s,t.copy(n,i),s+=o.data.length,o=o.next;return a},e}(),i&&i.inspect&&i.inspect.custom&&(t.exports.prototype[i.inspect.custom]=function(){var e=i.inspect({length:this.length});return this.constructor.name+" "+e})},{"safe-buffer":107,util:3}],120:[function(e,t,n){"use strict";var r=e("process-nextick-args");function i(e,t){e.emit("error",t)}t.exports={destroy:function(e,t){var n=this,a=this._readableState&&this._readableState.destroyed,o=this._writableState&&this._writableState.destroyed;return a||o?(t?t(e):!e||this._writableState&&this._writableState.errorEmitted||r.nextTick(i,this,e),this):(this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(e||null,function(e){!t&&e?(r.nextTick(i,n,e),n._writableState&&(n._writableState.errorEmitted=!0)):t&&t(e)}),this)},undestroy:function(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}}},{"process-nextick-args":97}],121:[function(e,t,n){t.exports=e("events").EventEmitter},{events:43}],122:[function(e,t,n){t.exports=e("./readable").PassThrough},{"./readable":123}],123:[function(e,t,n){(n=t.exports=e("./lib/_stream_readable.js")).Stream=n,n.Readable=n,n.Writable=e("./lib/_stream_writable.js"),n.Duplex=e("./lib/_stream_duplex.js"),n.Transform=e("./lib/_stream_transform.js"),n.PassThrough=e("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":114,"./lib/_stream_passthrough.js":115,"./lib/_stream_readable.js":116,"./lib/_stream_transform.js":117,"./lib/_stream_writable.js":118}],124:[function(e,t,n){t.exports=e("./readable").Transform},{"./readable":123}],125:[function(e,t,n){t.exports=e("./lib/_stream_writable.js")},{"./lib/_stream_writable.js":118}],126:[function(e,t,n){"use strict";var r=e("safe-buffer").Buffer,i=r.isEncoding||function(e){switch((e=""+e)&&e.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!0;default:return!1}};function a(e){var t;switch(this.encoding=function(e){var t=function(e){if(!e)return"utf8";for(var t;;)switch(e){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return e;default:if(t)return;e=(""+e).toLowerCase(),t=!0}}(e);if("string"!=typeof t&&(r.isEncoding===i||!i(e)))throw new Error("Unknown encoding: "+e);return t||e}(e),this.encoding){case"utf16le":this.text=u,this.end=l,t=4;break;case"utf8":this.fillLast=s,t=4;break;case"base64":this.text=c,this.end=f,t=3;break;default:return this.write=h,void(this.end=p)}this.lastNeed=0,this.lastTotal=0,this.lastChar=r.allocUnsafe(t)}function o(e){return e<=127?0:e>>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function s(e){var t=this.lastTotal-this.lastNeed,n=function(e,t,n){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(e.lastNeed>1&&t.length>1){if(128!=(192&t[1]))return e.lastNeed=1,"�";if(e.lastNeed>2&&t.length>2&&128!=(192&t[2]))return e.lastNeed=2,"�"}}(this,e);return void 0!==n?n:this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(e.copy(this.lastChar,t,0,e.length),void(this.lastNeed-=e.length))}function u(e,t){if((e.length-t)%2==0){var n=e.toString("utf16le",t);if(n){var r=n.charCodeAt(n.length-1);if(r>=55296&&r<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],n.slice(0,-1)}return n}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString("utf16le",t,e.length-1)}function l(e){var t=e&&e.length?this.write(e):"";if(this.lastNeed){var n=this.lastTotal-this.lastNeed;return t+this.lastChar.toString("utf16le",0,n)}return t}function c(e,t){var n=(e.length-t)%3;return 0===n?e.toString("base64",t):(this.lastNeed=3-n,this.lastTotal=3,1===n?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString("base64",t,e.length-n))}function f(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+this.lastChar.toString("base64",0,3-this.lastNeed):t}function h(e){return e.toString(this.encoding)}function p(e){return e&&e.length?this.write(e):""}n.StringDecoder=a,a.prototype.write=function(e){if(0===e.length)return"";var t,n;if(this.lastNeed){if(void 0===(t=this.fillLast(e)))return"";n=this.lastNeed,this.lastNeed=0}else n=0;return n=0)return i>0&&(e.lastNeed=i-1),i;if(--r=0)return i>0&&(e.lastNeed=i-2),i;if(--r=0)return i>0&&(2===i?i=0:e.lastNeed=i-3),i;return 0}(this,e,t);if(!this.lastNeed)return e.toString("utf8",t);this.lastTotal=n;var r=e.length-(n-this.lastNeed);return e.copy(this.lastChar,0,r),e.toString("utf8",t,r)},a.prototype.fillLast=function(e){if(this.lastNeed<=e.length)return e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,e.length),this.lastNeed-=e.length}},{"safe-buffer":107}],127:[function(e,t,n){(function(n){var r=e("stream");function i(e,t,i){e=e||function(e){this.queue(e)},t=t||function(){this.queue(null)};var a=!1,o=!1,s=[],u=!1,l=new r;function c(){for(;s.length&&!l.paused;){var e=s.shift();if(null===e)return l.emit("end");l.emit("data",e)}}return l.readable=l.writable=!0,l.paused=!1,l.autoDestroy=!(i&&!1===i.autoDestroy),l.write=function(t){return e.call(this,t),!l.paused},l.queue=l.push=function(e){return u?l:(null===e&&(u=!0),s.push(e),c(),l)},l.on("end",function(){l.readable=!1,!l.writable&&l.autoDestroy&&n.nextTick(function(){l.destroy()})}),l.end=function(e){if(!a)return a=!0,arguments.length&&l.write(e),l.writable=!1,t.call(l),!l.readable&&l.autoDestroy&&l.destroy(),l},l.destroy=function(){if(!o)return o=!0,a=!0,s.length=0,l.writable=l.readable=!1,l.emit("close"),l},l.pause=function(){if(!l.paused)return l.paused=!0,l},l.resume=function(){return l.paused&&(l.paused=!1,l.emit("resume")),c(),l.paused||l.emit("drain"),l},l}t.exports=i,i.through=i}).call(this,e("_process"))},{_process:98,stream:112}],128:[function(e,t,n){(function(t,r){var i=e("process/browser.js").nextTick,a=Function.prototype.apply,o=Array.prototype.slice,s={},u=0;function l(e,t){this._id=e,this._clearFn=t}n.setTimeout=function(){return new l(a.call(setTimeout,window,arguments),clearTimeout)},n.setInterval=function(){return new l(a.call(setInterval,window,arguments),clearInterval)},n.clearTimeout=n.clearInterval=function(e){e.close()},l.prototype.unref=l.prototype.ref=function(){},l.prototype.close=function(){this._clearFn.call(window,this._id)},n.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},n.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},n._unrefActive=n.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout(function(){e._onTimeout&&e._onTimeout()},t))},n.setImmediate="function"==typeof t?t:function(e){var t=u++,r=!(arguments.length<2)&&o.call(arguments,1);return s[t]=!0,i(function(){s[t]&&(r?e.apply(null,r):e.call(null),n.clearImmediate(t))}),t},n.clearImmediate="function"==typeof r?r:function(e){delete s[e]}}).call(this,e("timers").setImmediate,e("timers").clearImmediate)},{"process/browser.js":98,timers:128}],129:[function(e,t,n){n.isatty=function(){return!1},n.ReadStream=function(){throw new Error("tty.ReadStream is not implemented")},n.WriteStream=function(){throw new Error("tty.WriteStream is not implemented")}},{}],130:[function(e,t,n){(function(t,r){"use strict";var i=e("bit-twiddle"),a=e("dup");t.__TYPEDARRAY_POOL||(t.__TYPEDARRAY_POOL={UINT8:a([32,0]),UINT16:a([32,0]),UINT32:a([32,0]),INT8:a([32,0]),INT16:a([32,0]),INT32:a([32,0]),FLOAT:a([32,0]),DOUBLE:a([32,0]),DATA:a([32,0]),UINT8C:a([32,0]),BUFFER:a([32,0])});var o="undefined"!=typeof Uint8ClampedArray,s=t.__TYPEDARRAY_POOL;s.UINT8C||(s.UINT8C=a([32,0])),s.BUFFER||(s.BUFFER=a([32,0]));var u=s.DATA,l=s.BUFFER;function c(e){if(e){var t=e.length||e.byteLength,n=i.log2(t);u[n].push(e)}}function f(e){e=i.nextPow2(e);var t=i.log2(e),n=u[t];return n.length>0?n.pop():new ArrayBuffer(e)}function h(e){return new Uint8Array(f(e),0,e)}function p(e){return new Uint16Array(f(2*e),0,e)}function d(e){return new Uint32Array(f(4*e),0,e)}function g(e){return new Int8Array(f(e),0,e)}function v(e){return new Int16Array(f(2*e),0,e)}function m(e){return new Int32Array(f(4*e),0,e)}function _(e){return new Float32Array(f(4*e),0,e)}function w(e){return new Float64Array(f(8*e),0,e)}function b(e){return o?new Uint8ClampedArray(f(e),0,e):h(e)}function y(e){return new DataView(f(e),0,e)}function x(e){e=i.nextPow2(e);var t=i.log2(e),n=l[t];return n.length>0?n.pop():new r(e)}n.free=function(e){if(r.isBuffer(e))l[i.log2(e.length)].push(e);else{if("[object ArrayBuffer]"!==Object.prototype.toString.call(e)&&(e=e.buffer),!e)return;var t=e.length||e.byteLength,n=0|i.log2(t);u[n].push(e)}},n.freeUint8=n.freeUint16=n.freeUint32=n.freeInt8=n.freeInt16=n.freeInt32=n.freeFloat32=n.freeFloat=n.freeFloat64=n.freeDouble=n.freeUint8Clamped=n.freeDataView=function(e){c(e.buffer)},n.freeArrayBuffer=c,n.freeBuffer=function(e){l[i.log2(e.length)].push(e)},n.malloc=function(e,t){if(void 0===t||"arraybuffer"===t)return f(e);switch(t){case"uint8":return h(e);case"uint16":return p(e);case"uint32":return d(e);case"int8":return g(e);case"int16":return v(e);case"int32":return m(e);case"float":case"float32":return _(e);case"double":case"float64":return w(e);case"uint8_clamped":return b(e);case"buffer":return x(e);case"data":case"dataview":return y(e);default:return null}return null},n.mallocArrayBuffer=f,n.mallocUint8=h,n.mallocUint16=p,n.mallocUint32=d,n.mallocInt8=g,n.mallocInt16=v,n.mallocInt32=m,n.mallocFloat32=n.mallocFloat=_,n.mallocFloat64=n.mallocDouble=w,n.mallocUint8Clamped=b,n.mallocDataView=y,n.mallocBuffer=x,n.clearCache=function(){for(var e=0;e<32;++e)s.UINT8[e].length=0,s.UINT16[e].length=0,s.UINT32[e].length=0,s.INT8[e].length=0,s.INT16[e].length=0,s.INT32[e].length=0,s.FLOAT[e].length=0,s.DOUBLE[e].length=0,s.UINT8C[e].length=0,u[e].length=0,l[e].length=0}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"bit-twiddle":2,buffer:4,dup:14}],131:[function(e,t,n){"use strict";t.exports=function(e,t,n){return 0===e.length?e:t?(n||e.sort(t),function(e,t){for(var n=1,r=e.length,i=e[0],a=e[0],o=1;o=o?u+1:o}r.mkdir(t+"sequencer"+o,function(){var a=t+"sequencer"+o+"/";for(var s in n.images){var u=n.images[s].steps;if(i){var l=u.slice(-1)[0].output.src,c=u.slice(-1)[0].output.format,f=e("data-uri-to-buffer")(l);r.writeFile(a+s+"_"+(u.length-1)+"."+c,f,function(){})}else for(var h in u){l=u[h].output.src,c=u[h].output.format,f=e("data-uri-to-buffer")(l);r.writeFile(a+s+"_"+h+"."+c,f,function(){})}}})},r.readdir(c,function(e,t){var n=[];if(void 0===t||0==t.length)return f(n),[];for(var i=0;i0&&(thisStep=c[e].steps[t],thisStep.UI.onRemove(thisStep.options.step),c[e].steps.splice(t,1))}function g(){var t=[],n=this;for(var r in arguments)t.push(a(arguments[r]));var i=l.call(this,t,"l");f.push({method:"loadImages",json_q:a(i)});var o=this.copy(i.loadedimages),s={name:"ImageSequencer Wrapper",sequencer:this,addSteps:this.addSteps,removeSteps:this.removeSteps,insertSteps:this.insertSteps,run:this.run,UI:this.UI,setUI:this.setUI,images:o};!function t(r){if(r!=o.length){var a=o[r];e("./ui/LoadImage")(n,a,i.images[a],function(){t(++r)})}else i.callback.call(s)}(0)}function v(e){var t={};if("load-image"==e)return{};if(0==arguments.length){for(var n in this.modules)t[n]=s[n][1];for(var r in this.sequences)t[r]={name:r,steps:u[r]}}else t=s[e]?s[e][1]:{inputs:u[e].options};return t}function m(e){let t=a(v(e.options.name).inputs);t=t||{};for(let n in t)t[n]=e.options[n]||t[n].default,t[n]=encodeURIComponent(t[n]);var n=Object.keys(t).map(e=>e+":"+t[e]).join("|");return`${e.options.name}{${n}}`}function _(e){let t;return(t=e.includes(",")?e.split(","):[e]).map(w)}function w(e){var t;if(t=e.includes("{")?e.includes("(")&&e.indexOf("(")=t.images[u].steps.length?{options:{name:void 0}}:t.images[u].steps.slice(f+e)[0]},t.images[u].steps[f].getIndex=function(){return f},r)r.hasOwnProperty(p)&&(t.images[u].steps[f][p]=r[p]);t.images[u].steps[f].UI.onDraw(t.images[u].steps[f].options.step);var d=e("./RunToolkit")(t.copy(h));t.images[u].steps[f].draw(d,function(){t.images[u].steps[f].options.step.output=t.images[u].steps[f].output.src,t.images[u].steps[f].UI.onComplete(t.images[u].steps[f].options.step),n(a,++s)},o)}}(s,a)}(n=function(e){for(var n in e)0==e[n]&&1==t.images[n].steps.length?delete e[n]:0==e[n]&&e[n]++;for(var n in e)for(var r=t.images[n].steps[e[n]-1];void 0===r||void 0===r.output;)r=t.images[n].steps[--e[n]-1];return e}(n))}},{"./RunToolkit":144,"./util/getStep.js":222}],144:[function(e,t,n){const r=e("get-pixels"),i=e("./modules/_nomodule/PixelManipulation"),a=e("lodash"),o=e("data-uri-to-buffer"),s=e("save-pixels");t.exports=function(e){return e.getPixels=r,e.pixelManipulation=i,e.lodash=a,e.dataUriToBuffer=o,e.savePixels=s,e}},{"./modules/_nomodule/PixelManipulation":217,"data-uri-to-buffer":13,"get-pixels":23,lodash:62,"save-pixels":111}],145:[function(e,t,n){t.exports={sample:[{name:"invert",options:{}},{name:"channel",options:{channel:"red"}},{name:"blur",options:{blur:"5"}}]}},{}],146:[function(e,t,n){t.exports=function(t,n){return t.blur=t.blur||2,t.step.metadata=t.step.metadata||{},{options:t,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return e("../_nomodule/PixelManipulation.js")(n,{output:function(e,t,n){a.output={src:t,format:n}},changePixel:function(e,t,n,r){return[e,t,n,r]},extraManipulation:function(e){for(var n=[0,0,0,0],r=0;rAverages (r, g, b, a): "+n.join(", ")+"

"),e},format:n.format,image:t.image,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":217}],147:[function(e,t,n){t.exports=[e("./Module"),e("./info.json")]},{"./Module":146,"./info.json":148}],148:[function(e,t,n){t.exports={name:"Average",description:"Average all pixel color",inputs:{}}},{}],149:[function(require,module,exports){module.exports=function Dynamic(options,UI,util){var output;function draw(input,callback,progressObj){progressObj.stop(!0),progressObj.overrideFlag=!0;var step=this;"string"==typeof options.func&&eval("options.func = "+options.func);var getPixels=require("get-pixels"),priorStep=this.getStep(-2);getPixels(priorStep.output.src,function(e,t){return options.firstImagePixels=t,require("../_nomodule/PixelManipulation.js")(input,{output:function(e,t,n){step.output={src:t,format:n}},changePixel:function(e,t,n,r,i,a){var o=options.firstImagePixels;return options.func(e,t,n,r,o.get(i,a,0),o.get(i,a,1),o.get(i,a,2),o.get(i,a,3))},format:input.format,image:options.image,inBrowser:options.inBrowser,callback:callback})})}return options.func=options.func||"function(r1, g1, b1, a1, r2, g2, b2, a2) { return [ r1, g2, b2, a2 ] }",{options:options,draw:draw,output:output,UI:UI}}},{"../_nomodule/PixelManipulation.js":217,"get-pixels":23}],150:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":149,"./info.json":151,dup:147}],151:[function(e,t,n){t.exports={name:"Blend",description:"Blend the past two image steps with the given function. Defaults to using the red channel from image 1 and the green and blue and alpha channels of image 2. Easier to use interfaces coming soon!",inputs:{blend:{type:"input",desc:"Function to use to blend the two images.",default:"function(r1, g1, b1, a1, r2, g2, b2, a2) { return [ r1, g2, b2, a2 ] }"}}}},{}],152:[function(e,t,n){t.exports=function(e,t){let n=[[2/159,4/159,5/159,4/159,2/159],[4/159,9/159,12/159,9/159,4/159],[5/159,12/159,15/159,12/159,5/159],[4/159,9/159,12/159,9/159,4/159],[2/159,4/159,5/159,4/159,2/159]],r=e;n=function(e){let t=[];for(let n=e.length-1;n>=0;n--){let r=[];for(let t=e[n].length-1;t>=0;t--)r.push(e[n][t]);t.push(r)}return t}(n);for(let t=0;tg;n=0<=g?++c:--c)r[n]=(t-i)/(a-i)*(u[n]-s[n])+s[n];return r}}t.exports=function(e,t){return t.colormap=t.colormap||i.default,"object"==typeof t.colormap?colormapFunction=r(t.colormap):i.hasOwnProperty(t.colormap)?colormapFunction=i[t.colormap]:colormapFunction=i.default,colormapFunction(e/255)};var i={greyscale:r([[0,[0,0,0],[255,255,255]],[1,[255,255,255],[255,255,255]]]),default:r([[0,[0,0,255],[0,255,0]],[.25,[0,255,0],[255,255,0]],[.5,[0,255,255],[255,255,0]],[.75,[255,255,0],[255,0,0]]]),ndvi:r([[0,[0,0,255],[38,195,195]],[.5,[0,150,0],[255,255,0]],[.75,[255,255,0],[255,50,50]]]),stretched:r([[0,[0,0,255],[0,0,255]],[.1,[0,0,255],[38,195,195]],[.5,[0,150,0],[255,255,0]],[.7,[255,255,0],[255,50,50]],[.9,[255,50,50],[255,50,50]]]),fastie:r([[0,[255,255,255],[0,0,0]],[.167,[0,0,0],[255,255,255]],[.33,[255,255,255],[0,0,0]],[.5,[0,0,0],[140,140,255]],[.55,[140,140,255],[0,255,0]],[.63,[0,255,0],[255,255,0]],[.75,[255,255,0],[255,0,0]],[.95,[255,0,0],[255,0,255]]])}},{}],166:[function(e,t,n){t.exports=function(t,n){return{options:t,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return e("../_nomodule/PixelManipulation.js")(n,{output:function(e,t,n){a.output={src:t,format:n}},changePixel:function(n,r,i,a){var o=(n+r+i)/3,s=e("./Colormap")(o,t);return[s[0],s[1],s[2],255]},format:n.format,image:t.image,inBrowser:t.inBrowser,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":217,"./Colormap":165}],167:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":166,"./info.json":168,dup:147}],168:[function(e,t,n){t.exports={name:"Colormap",description:"Maps brightness values (average of red, green & blue) to a given color lookup table, made up of a set of one more color gradients.\n\nFor example, 'cooler' colors like blue could represent low values, while 'hot' colors like red could represent high values.",inputs:{colormap:{type:"select",desc:"Name of the Colormap",default:"default",values:["default","greyscale","stretched","fastie"]}}}},{}],169:[function(e,t,n){var r=e("lodash");t.exports=function(e,t,n){let a=function(e,t){for(t=t.split(" "),i=0;i<9;i++)t[i]=Number(t[i])*e;let n=0,r=[];for(i=0;i<3;i++){let e=[];for(j=0;j<3;j++)e.push(t[n]),n+=1;r.push(e)}return r}(t,n),o=r.cloneDeep(e);a=function(e){let t=[];for(let n=e.length-1;n>=0;n--){let r=[];for(let t=e[n].length-1;t>=0;t--)r.push(e[n][t]);t.push(r)}return t}(a);for(let t=0;tRead more",inputs:{constantFactor:{type:"Float",desc:"a constant factor, multiplies all the kernel values by that factor",default:.1111,placeholder:.1111},kernelValues:{type:"String",desc:"nine space separated numbers representing the kernel values in left to right and top to bottom format.",default:"1 1 1 1 1 1 1 1 1",placeholder:"1 1 1 1 1 1 1 1 1"}}}},{}],173:[function(e,t,n){(function(n){t.exports=function(t,r,i){var a=e("get-pixels"),o=e("save-pixels");r.x=parseInt(r.x)||0,r.y=parseInt(r.y)||0,a(t.src,function(e,a){r.w=parseInt(r.w)||Math.floor(a.shape[0]),r.h=parseInt(r.h)||Math.floor(a.shape[1]);for(var s=r.x,u=r.y,l=r.w,c=r.h,f=a.shape[0],h=new Uint8Array(4*l*c),p=u;pInfragrammar.",inputs:{red:{type:"input",desc:"Expression to return for red channel with R, G, B, and A inputs",default:"r"},green:{type:"input",desc:"Expression to return for green channel with R, G, B, and A inputs",default:"g"},blue:{type:"input",desc:"Expression to return for blue channel with R, G, B, and A inputs",default:"b"},"monochrome (fallback)":{type:"input",desc:"Expression to return with R, G, B, and A inputs; fallback for other channels if none provided",default:"r + g + b"}}}},{}],184:[function(e,t,n){e("lodash");const r=[[-1,0,1],[-2,0,2],[-1,0,1]],i=[[-1,-2,-1],[0,0,0],[1,2,1]];function a(e,t,n,a,o){let s=0;for(let t=0;t<3;t++)for(let n=0;n<3;n++){let i=a+t-1,u=o+n-1;s+=e.get(i,u,0)*r[t][n]}let u=0;for(let t=0;t<3;t++)for(let n=0;n<3;n++){let r=a+t-1,s=o+n-1;u+=e.get(r,s,0)*i[t][n]}return{pixel:[t,t,t,Math.sqrt(Math.pow(s,2)+Math.pow(u,2))],angle:Math.atan2(u,s)}}t.exports=function(e,t,n,r){let i=[],u=[];for(var l=0;le.map(o));for(let r=1;r=-22.5&&a<=22.5||a<-157.5&&a>=-180?t[r][i]>=t[r][i+1]&&t[r][i]>=t[r][i-1]?e.set(r,i,3,t[r][i]):e.set(r,i,3,0):a>=22.5&&a<=67.5||a<-112.5&&a>=-157.5?t[r][i]>=t[r+1][i+1]&&t[r][i]>=t[r-1][i-1]?e.set(r,i,3,t[r][i]):e.set(r,i,3,0):a>=67.5&&a<=112.5||a<-67.5&&a>=-112.5?t[r][r]>=t[r+1][i]&&t[r][i]>=t[r][i]?e.set(r,i,3,t[r][i]):e.set(r,i,3,0):(a>=112.5&&a<=157.5||a<-22.5&&a>=-67.5)&&(t[r][i]>=t[r+1][i-1]&&t[r][i]>=t[r-1][i+1]?e.set(r,i,3,t[r][i]):e.set(r,i,3,0))}}(e,u,i),function(e,t,n,r,i,a){const o=s(r)*t,u=o*n;for(let t=0;tu?r[t][n]>o?i.push(s):a.push(s):e.set(t,n,3,0)}i.forEach(t=>e.set(t[0],t[1],3,255))}(e,t,n,u,[],[]),e};var o=e=>180*e/Math.PI,s=e=>Math.max(...e.map(e=>e.map(e=>e||0)).map(e=>Math.max(...e)))},{lodash:62}],185:[function(e,t,n){t.exports=function(t,n){return t.blur=t.blur||2,t.highThresholdRatio=t.highThresholdRatio||.2,t.lowThresholdRatio=t.lowThresholdRatio||.15,{options:t,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return e("../_nomodule/PixelManipulation.js")(n,{output:function(e,t,n){a.output={src:t,format:n}},changePixel:function(e,t,n,r){return[(e+t+n)/3,(e+t+n)/3,(e+t+n)/3,r]},extraManipulation:function(n){return n=e("ndarray-gaussian-filter")(n,t.blur),n=e("./EdgeUtils")(n,t.highThresholdRatio,t.lowThresholdRatio,t.inBrowser)},format:n.format,image:t.image,inBrowser:t.inBrowser,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":217,"./EdgeUtils":184,"ndarray-gaussian-filter":67}],186:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":185,"./info.json":187,dup:147}],187:[function(e,t,n){t.exports={name:"Detect Edges",description:"this module detects edges using the Canny method, which first Gaussian blurs the image to reduce noise (amount of blur configurable in settings as `options.blur`), then applies a number of steps to highlight edges, resulting in a greyscale image where the brighter the pixel, the stronger the detected edge. Read more at: https://en.wikipedia.org/wiki/Canny_edge_detector",inputs:{blur:{type:"integer",desc:"amount of gaussian blur(Less blur gives more detail, typically 0-5)",default:2},highThresholdRatio:{type:"float",desc:"The high threshold ratio for the image",default:.2},lowThresholdRatio:{type:"float",desc:"The low threshold value for the image",default:.15}}}},{}],188:[function(e,t,n){t.exports=function(t,n){return e("fisheyegl"),{options:t,draw:function(e,n){var r=this;if(t.inBrowser){if(document.querySelector("#image-sequencer-canvas"))var i=document.querySelector("#image-sequencer-canvas");else(i=document.createElement("canvas")).style.display="none",i.setAttribute("id","image-sequencer-canvas"),document.body.append(i);distorter=FisheyeGl({selector:"#image-sequencer-canvas"}),t.a=parseFloat(t.a)||distorter.lens.a,t.b=parseFloat(t.b)||distorter.lens.b,t.Fx=parseFloat(t.Fx)||distorter.lens.Fx,t.Fy=parseFloat(t.Fy)||distorter.lens.Fy,t.scale=parseFloat(t.scale)||distorter.lens.scale,t.x=parseFloat(t.x)||distorter.fov.x,t.y=parseFloat(t.y)||distorter.fov.y,distorter.lens.a=t.a,distorter.lens.b=t.b,distorter.lens.Fx=t.Fx,distorter.lens.Fy=t.Fy,distorter.lens.scale=t.scale,distorter.fov.x=t.x,distorter.fov.y=t.y,distorter.setImage(e.src,function(){r.output={src:i.toDataURL(),format:e.format},n()})}else this.output=e,n()},output:void 0,UI:n}}},{fisheyegl:15}],189:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":188,"./info.json":190,dup:147}],190:[function(e,t,n){t.exports={name:"Fisheye GL",description:"Correct fisheye, or barrel distortion, in images (with WebGL -- adapted from fisheye-correction-webgl by @bluemir).",requires:["webgl"],inputs:{a:{type:"float",desc:"a parameter",default:1,min:1,max:4},b:{type:"float",desc:"b parameter",default:1,min:1,max:4},Fx:{type:"float",desc:"Fx parameter",default:0,min:0,max:4},Fy:{type:"float",desc:"Fy parameter",default:0,min:0,max:4},scale:{type:"float",desc:"Image Scaling",default:1.5,min:0,max:20},x:{type:"float",desc:"FOV x parameter",default:1.5,min:0,max:20},y:{type:"float",desc:"FOV y parameter",default:1.5,min:0,max:20},fragmentSrc:{type:"PATH",desc:"Path to a WebGL fragment shader file",default:"(inbuilt)"},vertexSrc:{type:"PATH",desc:"Path to a WebGL vertex shader file",default:"(inbuilt)"}}}},{}],191:[function(e,t,n){t.exports=function(t,n){return{options:t,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return e("../_nomodule/PixelManipulation.js")(n,{output:function(e,t,n){a.output={src:t,format:n}},changePixel:function(e,n,r,i){var a=t.adjustment||.2;return[e=255*Math.pow(e/255,a),n=255*Math.pow(n/255,a),r=255*Math.pow(r/255,a),i]},format:n.format,image:t.image,inBrowser:t.inBrowser,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":217}],192:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":191,"./info.json":193,dup:147}],193:[function(e,t,n){t.exports={name:"Gamma Correction",description:"Apply gamma correction on the image Read more",inputs:{adjustment:{type:"float",desc:"gamma correction (inverse of actual gamma factor) for the new image",default:.2}}}},{}],194:[function(e,t,n){(function(n){t.exports=function(t,r){return{options:t,draw:function(t,r,i){var a=e("get-pixels"),o=e("save-pixels"),s=this;a(t.src,function(e,i){if(e)console.log("Bad Image path");else{for(var a=0,u=0;u

Select or drag in an image to overlay.

';$(e.ui).find(".details").prepend(i),sequencer.setInputStep({dropZoneSelector:"#"+r,fileInputSelector:"#"+r+" .file-input",onLoad:function(t){var n=t.target;e.options.imageUrl=n.result,e.options.url=n.result,sequencer.run(),setUrlHashParameter("steps",sequencer.toString())}}),$(e.ui).find(".btn-save").on("click",function(){var t=$(e.ui).find(".det input").val();e.options.imageUrl=t,sequencer.run()})}}}},{}],202:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":200,"./info.json":203,dup:147}],203:[function(e,t,n){t.exports={name:"Import Image",description:"Import a new image and replace the original with it. Future versions may enable a blend mode. Specify an image by URL or by file selector.",url:"https://github.com/publiclab/image-sequencer/tree/master/MODULES.md",inputs:{url:{type:"string",desc:"URL of image to import",default:"./images/monarch.png"}}}},{}],204:[function(e,t,n){t.exports=function(){return this.expandSteps([{name:"ndvi",options:{}},{name:"colormap",options:{}}]),{isMeta:!0}}},{}],205:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":204,"./info.json":206,dup:147}],206:[function(e,t,n){t.exports={name:"NDVI-Colormap",description:"Sequentially Applies NDVI and Colormap steps",inputs:{},length:2}},{}],207:[function(e,t,n){t.exports=function(t,n){if(t.step.inBrowser)var r=e("./Ui.js")(t.step,n);return t.filter=t.filter||"red",{options:t,draw:function(n,i,a){a.stop(!0),a.overrideFlag=!0;var o=this;return e("../_nomodule/PixelManipulation.js")(n,{output:function(e,t,n){o.output={src:t,format:n}},changePixel:function(e,n,r,i){if("red"==t.filter)var a=(r-e)/(1*r+e);"blue"==t.filter&&(a=(e-r)/(1*r+e));var o=255*(a+1)/2;return[o,o,o,i]},format:n.format,image:t.image,inBrowser:t.inBrowser,callback:function(){t.step.inBrowser&&r.setup(),i()}})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":217,"./Ui.js":208}],208:[function(e,t,n){t.exports=function(e,t){return{setup:function(){var t=$(e.imgElement);t.mousemove(function(e){var n=document.createElement("canvas");n.width=t.width(),n.height=t.height(),n.getContext("2d").drawImage(this,0,0);var r=$(this).offset(),i=e.pageX-r.left,a=e.pageY-r.top,o=n.getContext("2d").getImageData(i,a,1,1).data[0];o=(o=o/127.5-1).toFixed(2),t[0].title="NDVI: "+o})}}}},{}],209:[function(e,t,n){arguments[4][147][0].apply(n,arguments)},{"./Module":207,"./info.json":210,dup:147}],210:[function(e,t,n){t.exports={name:"NDVI",description:"Normalized Difference Vegetation Index, or NDVI, is an image analysis technique used with aerial photography. It's a way to visualize the amounts of infrared and other wavelengths of light reflected from vegetation by comparing ratios of blue and red light absorbed versus green and IR light reflected. NDVI is used to evaluate the health of vegetation in satellite imagery, where it correlates with how much photosynthesis is happening. This is helpful in assessing vegetative health or stress. Read more.

This is designed for use with red-filtered single camera DIY Infragram cameras; change to 'blue' for blue filters",inputs:{filter:{type:"select",desc:"Filter color",default:"red",values:["red","blue"]}}}},{}],211:[function(e,t,n){t.exports=function(t,n,r){return t.x=t.x||0,t.y=t.y||0,{options:t,draw:function(n,r,i){t.offset=t.offset||-2,i.stop(!0),i.overrideFlag=!0;var a=this,o=this.getStep(t.offset).image,s=this.getOutput(t.offset);e("get-pixels")(n.src,function(n,i){return t.secondImagePixels=i,e("../_nomodule/PixelManipulation.js")(s,{output:function(e,t,n){a.output={src:t,format:n}},changePixel:function(e,n,r,i,a,o){var s=t.secondImagePixels;return a>=t.x&&a=t.y&&o
To work with a new or different image, drag one into the drop zone.",ID:t.options.sequencerCounter++,imageName:e,inBrowser:t.options.inBrowser,ui:t.options.ui},o={src:n,steps:[{options:{id:r.ID,name:"load-image",description:"This initial step loads and displays the original image without any modifications.",title:"Load Image",step:r},UI:t.events,draw:function(){return UI.onDraw(options.step),1==arguments.length?(this.output=a(arguments[0]),options.step.output=this.output,UI.onComplete(options.step),!0):2==arguments.length&&(this.output=a(arguments[0]),options.step.output=this.output,arguments[1](),UI.onComplete(options.step),!0)}}]};a(n,function(n){var r=function(e){return{src:e,format:e.split(":")[1].split(";")[0].split("/")[1]}}(n);t.images[e]=o;var a=t.images[e].steps[0];return a.output=r,a.options.step.output=a.output.src,a.UI.onSetup(a.options.step),a.UI.onDraw(a.options.step),a.UI.onComplete(a.options.step),i(),!0})}(n,r)}},{urify:132}],219:[function(e,t,n){t.exports=function(){return function(e){var t=$(e.dropZoneSelector),n=$(e.fileInputSelector),r=e.onLoad;function i(e){if(e.preventDefault(),e.stopPropagation(),e.target&&e.target.files)var t=e.target.files[0];else t=e.dataTransfer.files[0];if(t){var n=new FileReader;n.onload=r,n.readAsDataURL(t)}}new FileReader,n.on("change",i),t[0].addEventListener("drop",i,!1),t.on("dragover",function(e){e.stopPropagation(),e.preventDefault(),e.dataTransfer.dropEffect="copy"},!1),t.on("dragenter",function(e){t.addClass("hover")}),t.on("dragleave",function(e){t.removeClass("hover")})}}},{}],220:[function(e,t,n){t.exports=function(e={}){return e.onSetup=e.onSetup||function(e){0==e.ui||(e.inBrowser?console.log('Added Step "'+e.name+'" to "'+e.imageName+'".'):console.log("%s",'Added Step "'+e.name+'" to "'+e.imageName+'".'))},e.onDraw=e.onDraw||function(e){0==e.ui||(e.inBrowser?console.log('Drawing Step "'+e.name+'" on "'+e.imageName+'".'):console.log("%s",'Drawing Step "'+e.name+'" on "'+e.imageName+'".'))},e.onComplete=e.onComplete||function(e){0==e.ui||(e.inBrowser?console.log('Drawn Step "'+e.name+'" on "'+e.imageName+'".'):console.log("%s",'Drawn Step "'+e.name+'" on "'+e.imageName+'".'))},e.onRemove=e.onRemove||function(e){0==e.ui||(e.inBrowser?console.log('Removing Step "'+e.name+'" of "'+e.imageName+'".'):console.log("%s",'Removing Step "'+e.name+'" of "'+e.imageName+'".'))},e}},{}],221:[function(e,t,n){t.exports=function(e){var t=void 0;return"jpeg"===(t=(t=function(e){return"data:image"===e.substr(0,10)}(e)?e.split(";")[0].split("/").pop():e.split(".").pop()).toLowerCase())&&(t="jpg"),["jpg","jpeg","png","gif","canvas"].includes(t)?t:"jpg"}},{}],222:[function(e,t,n){t.exports={getPreviousStep:function(){return this.getStep(-1)},getNextStep:function(){return this.getStep(1)},getInput:function(e){return e+this.getIndex()===0&&e++,this.getStep(e-1).output},getOutput:function(e){return this.getStep(e).output},getOptions:function(){return this.getStep(0).options},setOptions:function(e){let t=this.getStep(0).options;for(let n in e)t[n]&&(t[n]=e[n])},getFormat:function(){return this.getStep(-1).output.format},getHeight:function(e){let t=new Image;t.onload=function(){e(t.height)},t.src=this.getInput(0).src},getWidth:function(e){let t=new Image;t.onload=function(){e(t.width)},t.src=this.getInput(0).src}}},{}]},{},[139]); \ No newline at end of file +!function(){return function t(e,n,r){function i(o,s){if(!n[o]){if(!e[o]){var u="function"==typeof require&&require;if(!s&&u)return u(o,!0);if(a)return a(o,!0);var l=new Error("Cannot find module '"+o+"'");throw l.code="MODULE_NOT_FOUND",l}var c=n[o]={exports:{}};e[o][0].call(c.exports,function(t){return i(e[o][1][t]||t)},c,c.exports,t,e,n,r)}return n[o].exports}for(var a="function"==typeof require&&require,o=0;o0?r-4:r,f=0;f>16&255,s[u++]=e>>8&255,s[u++]=255&e;2===o&&(e=i[t.charCodeAt(f)]<<2|i[t.charCodeAt(f+1)]>>4,s[u++]=255&e);1===o&&(e=i[t.charCodeAt(f)]<<10|i[t.charCodeAt(f+1)]<<4|i[t.charCodeAt(f+2)]>>2,s[u++]=e>>8&255,s[u++]=255&e);return s},n.fromByteArray=function(t){for(var e,n=t.length,i=n%3,a=[],o=0,s=n-i;os?s:o+16383));1===i?(e=t[n-1],a.push(r[e>>2]+r[e<<4&63]+"==")):2===i&&(e=(t[n-2]<<8)+t[n-1],a.push(r[e>>10]+r[e>>4&63]+r[e<<2&63]+"="));return a.join("")};for(var r=[],i=[],a="undefined"!=typeof Uint8Array?Uint8Array:Array,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=0,u=o.length;s0)throw new Error("Invalid string. Length must be a multiple of 4");var n=t.indexOf("=");return-1===n&&(n=e),[n,n===e?0:4-n%4]}function c(t,e,n){for(var i,a,o=[],s=e;s>18&63]+r[a>>12&63]+r[a>>6&63]+r[63&a]);return o.join("")}i["-".charCodeAt(0)]=62,i["_".charCodeAt(0)]=63},{}],2:[function(t,e,n){"use strict";"use restrict";function r(t){var e=32;return(t&=-t)&&e--,65535&t&&(e-=16),16711935&t&&(e-=8),252645135&t&&(e-=4),858993459&t&&(e-=2),1431655765&t&&(e-=1),e}n.INT_BITS=32,n.INT_MAX=2147483647,n.INT_MIN=-1<<31,n.sign=function(t){return(t>0)-(t<0)},n.abs=function(t){var e=t>>31;return(t^e)-e},n.min=function(t,e){return e^(t^e)&-(t65535)<<4,e|=n=((t>>>=e)>255)<<3,e|=n=((t>>>=n)>15)<<2,(e|=n=((t>>>=n)>3)<<1)|(t>>>=n)>>1},n.log10=function(t){return t>=1e9?9:t>=1e8?8:t>=1e7?7:t>=1e6?6:t>=1e5?5:t>=1e4?4:t>=1e3?3:t>=100?2:t>=10?1:0},n.popCount=function(t){return 16843009*((t=(858993459&(t-=t>>>1&1431655765))+(t>>>2&858993459))+(t>>>4)&252645135)>>>24},n.countTrailingZeros=r,n.nextPow2=function(t){return t+=0===t,--t,t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)+1},n.prevPow2=function(t){return t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)-(t>>>1)},n.parity=function(t){return t^=t>>>16,t^=t>>>8,t^=t>>>4,27030>>>(t&=15)&1};var i=new Array(256);!function(t){for(var e=0;e<256;++e){var n=e,r=e,i=7;for(n>>>=1;n;n>>>=1)r<<=1,r|=1&n,--i;t[e]=r<>>8&255]<<16|i[t>>>16&255]<<8|i[t>>>24&255]},n.interleave2=function(t,e){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t&=65535)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e&=65535)|e<<8))|e<<4))|e<<2))|e<<1))<<1},n.deinterleave2=function(t,e){return(t=65535&((t=16711935&((t=252645135&((t=858993459&((t=t>>>e&1431655765)|t>>>1))|t>>>2))|t>>>4))|t>>>16))<<16>>16},n.interleave3=function(t,e,n){return t=1227133513&((t=3272356035&((t=251719695&((t=4278190335&((t&=1023)|t<<16))|t<<8))|t<<4))|t<<2),(t|=(e=1227133513&((e=3272356035&((e=251719695&((e=4278190335&((e&=1023)|e<<16))|e<<8))|e<<4))|e<<2))<<1)|(n=1227133513&((n=3272356035&((n=251719695&((n=4278190335&((n&=1023)|n<<16))|n<<8))|n<<4))|n<<2))<<2},n.deinterleave3=function(t,e){return(t=1023&((t=4278190335&((t=251719695&((t=3272356035&((t=t>>>e&1227133513)|t>>>2))|t>>>4))|t>>>8))|t>>>16))<<22>>22},n.nextCombination=function(t){var e=t|t-1;return e+1|(~e&-~e)-1>>>r(t)+1}},{}],3:[function(t,e,n){(function(t,r,i){!function(t){if("object"==typeof n&&void 0!==e)e.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var i;"undefined"!=typeof window?i=window:void 0!==r?i=r:"undefined"!=typeof self&&(i=self),i.Promise=t()}}(function(){var e,n,a;return function t(e,n,r){function i(o,s){if(!n[o]){if(!e[o]){var u="function"==typeof _dereq_&&_dereq_;if(!s&&u)return u(o,!0);if(a)return a(o,!0);var l=new Error("Cannot find module '"+o+"'");throw l.code="MODULE_NOT_FOUND",l}var c=n[o]={exports:{}};e[o][0].call(c.exports,function(t){var n=e[o][1][t];return i(n||t)},c,c.exports,t,e,n,r)}return n[o].exports}for(var a="function"==typeof _dereq_&&_dereq_,o=0;o0;)p(t)}function p(t){var e=t.shift();if("function"!=typeof e)e._settlePromises();else{var n=t.shift(),r=t.shift();e.call(n,r)}}u.prototype.setScheduler=function(t){var e=this._schedule;return this._schedule=t,this._customScheduler=!0,e},u.prototype.hasCustomScheduler=function(){return this._customScheduler},u.prototype.enableTrampoline=function(){this._trampolineEnabled=!0},u.prototype.disableTrampolineIfNecessary=function(){s.hasDevTools&&(this._trampolineEnabled=!1)},u.prototype.haveItemsQueued=function(){return this._isTickUsed||this._haveDrainedQueues},u.prototype.fatalError=function(e,n){n?(t.stderr.write("Fatal "+(e instanceof Error?e.stack:e)+"\n"),t.exit(2)):this.throwLater(e)},u.prototype.throwLater=function(t,e){if(1===arguments.length&&(e=t,t=function(){throw e}),"undefined"!=typeof setTimeout)setTimeout(function(){t(e)},0);else try{this._schedule(function(){t(e)})}catch(t){throw new Error("No async scheduler available\n\n See http://goo.gl/MqrFmX\n")}},s.hasDevTools?(u.prototype.invokeLater=function(t,e,n){this._trampolineEnabled?l.call(this,t,e,n):this._schedule(function(){setTimeout(function(){t.call(e,n)},100)})},u.prototype.invoke=function(t,e,n){this._trampolineEnabled?c.call(this,t,e,n):this._schedule(function(){t.call(e,n)})},u.prototype.settlePromises=function(t){this._trampolineEnabled?f.call(this,t):this._schedule(function(){t._settlePromises()})}):(u.prototype.invokeLater=l,u.prototype.invoke=c,u.prototype.settlePromises=f),u.prototype._drainQueues=function(){h(this._normalQueue),this._reset(),this._haveDrainedQueues=!0,h(this._lateQueue)},u.prototype._queueTick=function(){this._isTickUsed||(this._isTickUsed=!0,this._schedule(this.drainQueues))},u.prototype._reset=function(){this._isTickUsed=!1},n.exports=u,n.exports.firstLineError=i},{"./queue":26,"./schedule":29,"./util":36}],3:[function(t,e,n){"use strict";e.exports=function(t,e,n,r){var i=!1,a=function(t,e){this._reject(e)},o=function(t,e){e.promiseRejectionQueued=!0,e.bindingPromise._then(a,a,null,this,t)},s=function(t,e){0==(50397184&this._bitField)&&this._resolveCallback(e.target)},u=function(t,e){e.promiseRejectionQueued||this._reject(t)};t.prototype.bind=function(a){i||(i=!0,t.prototype._propagateFrom=r.propagateFromFunction(),t.prototype._boundValue=r.boundValueFunction());var l=n(a),c=new t(e);c._propagateFrom(this,1);var f=this._target();if(c._setBoundTo(l),l instanceof t){var h={promiseRejectionQueued:!1,promise:c,target:f,bindingPromise:l};f._then(e,o,void 0,c,h),l._then(s,u,void 0,c,h),c._setOnCancel(l)}else c._resolveCallback(f);return c},t.prototype._setBoundTo=function(t){void 0!==t?(this._bitField=2097152|this._bitField,this._boundTo=t):this._bitField=-2097153&this._bitField},t.prototype._isBound=function(){return 2097152==(2097152&this._bitField)},t.bind=function(e,n){return t.resolve(n).bind(e)}}},{}],4:[function(t,e,n){"use strict";var r;"undefined"!=typeof Promise&&(r=Promise);var i=t("./promise")();i.noConflict=function(){try{Promise===i&&(Promise=r)}catch(t){}return i},e.exports=i},{"./promise":22}],5:[function(t,e,n){"use strict";var r=Object.create;if(r){var i=r(null),a=r(null);i[" size"]=a[" size"]=0}e.exports=function(e){var n,r=t("./util"),i=r.canEvaluate;r.isIdentifier;function a(t,n){var i;if(null!=t&&(i=t[n]),"function"!=typeof i){var a="Object "+r.classString(t)+" has no method '"+r.toString(n)+"'";throw new e.TypeError(a)}return i}function o(t){return a(t,this.pop()).apply(t,this)}function s(t){return t[this]}function u(t){var e=+this;return e<0&&(e=Math.max(0,e+t.length)),t[e]}e.prototype.call=function(t){var e=[].slice.call(arguments,1);return e.push(t),this._then(o,void 0,void 0,e,void 0)},e.prototype.get=function(t){var e;if("number"==typeof t)e=u;else if(i){var r=n(t);e=null!==r?r:s}else e=s;return this._then(e,void 0,void 0,t,void 0)}}},{"./util":36}],6:[function(t,e,n){"use strict";e.exports=function(e,n,r,i){var a=t("./util"),o=a.tryCatch,s=a.errorObj,u=e._async;e.prototype.break=e.prototype.cancel=function(){if(!i.cancellation())return this._warn("cancellation is disabled");for(var t=this,e=t;t._isCancellable();){if(!t._cancelBy(e)){e._isFollowing()?e._followee().cancel():e._cancelBranched();break}var n=t._cancellationParent;if(null==n||!n._isCancellable()){t._isFollowing()?t._followee().cancel():t._cancelBranched();break}t._isFollowing()&&t._followee().cancel(),t._setWillBeCancelled(),e=t,t=n}},e.prototype._branchHasCancelled=function(){this._branchesRemainingToCancel--},e.prototype._enoughBranchesHaveCancelled=function(){return void 0===this._branchesRemainingToCancel||this._branchesRemainingToCancel<=0},e.prototype._cancelBy=function(t){return t===this?(this._branchesRemainingToCancel=0,this._invokeOnCancel(),!0):(this._branchHasCancelled(),!!this._enoughBranchesHaveCancelled()&&(this._invokeOnCancel(),!0))},e.prototype._cancelBranched=function(){this._enoughBranchesHaveCancelled()&&this._cancel()},e.prototype._cancel=function(){this._isCancellable()&&(this._setCancelled(),u.invoke(this._cancelPromises,this,void 0))},e.prototype._cancelPromises=function(){this._length()>0&&this._settlePromises()},e.prototype._unsetOnCancel=function(){this._onCancelField=void 0},e.prototype._isCancellable=function(){return this.isPending()&&!this._isCancelled()},e.prototype.isCancellable=function(){return this.isPending()&&!this.isCancelled()},e.prototype._doInvokeOnCancel=function(t,e){if(a.isArray(t))for(var n=0;n=0)return n[t]}return t.prototype._promiseCreated=function(){},t.prototype._pushContext=function(){},t.prototype._popContext=function(){return null},t._peekContext=t.prototype._peekContext=function(){},r.prototype._pushContext=function(){void 0!==this._trace&&(this._trace._promiseCreated=null,n.push(this._trace))},r.prototype._popContext=function(){if(void 0!==this._trace){var t=n.pop(),e=t._promiseCreated;return t._promiseCreated=null,e}return null},r.CapturedTrace=null,r.create=function(){if(e)return new r},r.deactivateLongStackTraces=function(){},r.activateLongStackTraces=function(){var n=t.prototype._pushContext,a=t.prototype._popContext,o=t._peekContext,s=t.prototype._peekContext,u=t.prototype._promiseCreated;r.deactivateLongStackTraces=function(){t.prototype._pushContext=n,t.prototype._popContext=a,t._peekContext=o,t.prototype._peekContext=s,t.prototype._promiseCreated=u,e=!1},e=!0,t.prototype._pushContext=r.prototype._pushContext,t.prototype._popContext=r.prototype._popContext,t._peekContext=t.prototype._peekContext=i,t.prototype._promiseCreated=function(){var t=this._peekContext();t&&null==t._promiseCreated&&(t._promiseCreated=this)}},r}},{}],9:[function(e,n,r){"use strict";n.exports=function(n,r){var i,a,o,s=n._getDomain,u=n._async,l=e("./errors").Warning,c=e("./util"),f=e("./es5"),h=c.canAttachTrace,p=/[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/,d=/\((?:timers\.js):\d+:\d+\)/,v=/[\/<\(](.+?):(\d+):(\d+)\)?\s*$/,g=null,m=null,_=!1,y=!(0==c.env("BLUEBIRD_DEBUG")),w=!(0==c.env("BLUEBIRD_WARNINGS")||!y&&!c.env("BLUEBIRD_WARNINGS")),b=!(0==c.env("BLUEBIRD_LONG_STACK_TRACES")||!y&&!c.env("BLUEBIRD_LONG_STACK_TRACES")),x=0!=c.env("BLUEBIRD_W_FORGOTTEN_RETURN")&&(w||!!c.env("BLUEBIRD_W_FORGOTTEN_RETURN"));n.prototype.suppressUnhandledRejections=function(){var t=this._target();t._bitField=-1048577&t._bitField|524288},n.prototype._ensurePossibleRejectionHandled=function(){if(0==(524288&this._bitField)){this._setRejectionIsUnhandled();var t=this;setTimeout(function(){t._notifyUnhandledRejection()},1)}},n.prototype._notifyUnhandledRejectionIsHandled=function(){H("rejectionHandled",i,void 0,this)},n.prototype._setReturnedNonUndefined=function(){this._bitField=268435456|this._bitField},n.prototype._returnedNonUndefined=function(){return 0!=(268435456&this._bitField)},n.prototype._notifyUnhandledRejection=function(){if(this._isRejectionUnhandled()){var t=this._settledValue();this._setUnhandledRejectionIsNotified(),H("unhandledRejection",a,t,this)}},n.prototype._setUnhandledRejectionIsNotified=function(){this._bitField=262144|this._bitField},n.prototype._unsetUnhandledRejectionIsNotified=function(){this._bitField=-262145&this._bitField},n.prototype._isUnhandledRejectionNotified=function(){return(262144&this._bitField)>0},n.prototype._setRejectionIsUnhandled=function(){this._bitField=1048576|this._bitField},n.prototype._unsetRejectionIsUnhandled=function(){this._bitField=-1048577&this._bitField,this._isUnhandledRejectionNotified()&&(this._unsetUnhandledRejectionIsNotified(),this._notifyUnhandledRejectionIsHandled())},n.prototype._isRejectionUnhandled=function(){return(1048576&this._bitField)>0},n.prototype._warn=function(t,e,n){return z(t,e,n||this)},n.onPossiblyUnhandledRejection=function(t){var e=s();a="function"==typeof t?null===e?t:c.domainBind(e,t):void 0},n.onUnhandledRejectionHandled=function(t){var e=s();i="function"==typeof t?null===e?t:c.domainBind(e,t):void 0};var k=function(){};n.longStackTraces=function(){if(u.haveItemsQueued()&&!K.longStackTraces)throw new Error("cannot enable long stack traces after promises have been created\n\n See http://goo.gl/MqrFmX\n");if(!K.longStackTraces&&Z()){var t=n.prototype._captureStackTrace,e=n.prototype._attachExtraTrace,i=n.prototype._dereferenceTrace;K.longStackTraces=!0,k=function(){if(u.haveItemsQueued()&&!K.longStackTraces)throw new Error("cannot enable long stack traces after promises have been created\n\n See http://goo.gl/MqrFmX\n");n.prototype._captureStackTrace=t,n.prototype._attachExtraTrace=e,n.prototype._dereferenceTrace=i,r.deactivateLongStackTraces(),u.enableTrampoline(),K.longStackTraces=!1},n.prototype._captureStackTrace=D,n.prototype._attachExtraTrace=N,n.prototype._dereferenceTrace=U,r.activateLongStackTraces(),u.disableTrampolineIfNecessary()}},n.hasLongStackTraces=function(){return K.longStackTraces&&Z()};var E=function(){try{if("function"==typeof CustomEvent){var t=new CustomEvent("CustomEvent");return c.global.dispatchEvent(t),function(t,e){var n={detail:e,cancelable:!0};f.defineProperty(n,"promise",{value:e.promise}),f.defineProperty(n,"reason",{value:e.reason});var r=new CustomEvent(t.toLowerCase(),n);return!c.global.dispatchEvent(r)}}if("function"==typeof Event){t=new Event("CustomEvent");return c.global.dispatchEvent(t),function(t,e){var n=new Event(t.toLowerCase(),{cancelable:!0});return n.detail=e,f.defineProperty(n,"promise",{value:e.promise}),f.defineProperty(n,"reason",{value:e.reason}),!c.global.dispatchEvent(n)}}return(t=document.createEvent("CustomEvent")).initCustomEvent("testingtheevent",!1,!0,{}),c.global.dispatchEvent(t),function(t,e){var n=document.createEvent("CustomEvent");return n.initCustomEvent(t.toLowerCase(),!1,!0,e),!c.global.dispatchEvent(n)}}catch(t){}return function(){return!1}}(),S=c.isNode?function(){return t.emit.apply(t,arguments)}:c.global?function(t){var e="on"+t.toLowerCase(),n=c.global[e];return!!n&&(n.apply(c.global,[].slice.call(arguments,1)),!0)}:function(){return!1};function j(t,e){return{promise:e}}var T={promiseCreated:j,promiseFulfilled:j,promiseRejected:j,promiseResolved:j,promiseCancelled:j,promiseChained:function(t,e,n){return{promise:e,child:n}},warning:function(t,e){return{warning:e}},unhandledRejection:function(t,e,n){return{reason:e,promise:n}},rejectionHandled:j},A=function(t){var e=!1;try{e=S.apply(null,arguments)}catch(t){u.throwLater(t),e=!0}var n=!1;try{n=E(t,T[t].apply(null,arguments))}catch(t){u.throwLater(t),n=!0}return n||e};function C(){return!1}function M(t,e,n){var r=this;try{t(e,n,function(t){if("function"!=typeof t)throw new TypeError("onCancel must be a function, got: "+c.toString(t));r._attachCancellationCallback(t)})}catch(t){return t}}function I(t){if(!this._isCancellable())return this;var e=this._onCancel();void 0!==e?c.isArray(e)?e.push(t):this._setOnCancel([e,t]):this._setOnCancel(t)}function R(){return this._onCancelField}function L(t){this._onCancelField=t}function B(){this._cancellationParent=void 0,this._onCancelField=void 0}function F(t,e){if(0!=(1&e)){this._cancellationParent=t;var n=t._branchesRemainingToCancel;void 0===n&&(n=0),t._branchesRemainingToCancel=n+1}0!=(2&e)&&t._isBound()&&this._setBoundTo(t._boundTo)}n.config=function(t){if("longStackTraces"in(t=Object(t))&&(t.longStackTraces?n.longStackTraces():!t.longStackTraces&&n.hasLongStackTraces()&&k()),"warnings"in t){var e=t.warnings;K.warnings=!!e,x=K.warnings,c.isObject(e)&&"wForgottenReturn"in e&&(x=!!e.wForgottenReturn)}if("cancellation"in t&&t.cancellation&&!K.cancellation){if(u.haveItemsQueued())throw new Error("cannot enable cancellation after promises are in use");n.prototype._clearCancellationData=B,n.prototype._propagateFrom=F,n.prototype._onCancel=R,n.prototype._setOnCancel=L,n.prototype._attachCancellationCallback=I,n.prototype._execute=M,P=F,K.cancellation=!0}return"monitoring"in t&&(t.monitoring&&!K.monitoring?(K.monitoring=!0,n.prototype._fireEvent=A):!t.monitoring&&K.monitoring&&(K.monitoring=!1,n.prototype._fireEvent=C)),n},n.prototype._fireEvent=C,n.prototype._execute=function(t,e,n){try{t(e,n)}catch(t){return t}},n.prototype._onCancel=function(){},n.prototype._setOnCancel=function(t){},n.prototype._attachCancellationCallback=function(t){},n.prototype._captureStackTrace=function(){},n.prototype._attachExtraTrace=function(){},n.prototype._dereferenceTrace=function(){},n.prototype._clearCancellationData=function(){},n.prototype._propagateFrom=function(t,e){};var P=function(t,e){0!=(2&e)&&t._isBound()&&this._setBoundTo(t._boundTo)};function O(){var t=this._boundTo;return void 0!==t&&t instanceof n?t.isFulfilled()?t.value():void 0:t}function D(){this._trace=new J(this._peekContext())}function N(t,e){if(h(t)){var n=this._trace;if(void 0!==n&&e&&(n=n._parent),void 0!==n)n.attachExtraTrace(t);else if(!t.__stackCleaned__){var r=V(t);c.notEnumerableProp(t,"stack",r.message+"\n"+r.stack.join("\n")),c.notEnumerableProp(t,"__stackCleaned__",!0)}}}function U(){this._trace=void 0}function z(t,e,r){if(K.warnings){var i,a=new l(t);if(e)r._attachExtraTrace(a);else if(K.longStackTraces&&(i=n._peekContext()))i.attachExtraTrace(a);else{var o=V(a);a.stack=o.message+"\n"+o.stack.join("\n")}A("warning",a)||G(a,"",!0)}}function q(t){for(var e=[],n=0;n0?function(t){for(var e=t.stack.replace(/\s+$/g,"").split("\n"),n=0;n0&&"SyntaxError"!=t.name&&(e=e.slice(n)),e}(t):[" (No stack trace)"],{message:n,stack:"SyntaxError"==t.name?e:q(e)}}function G(t,e,n){if("undefined"!=typeof console){var r;if(c.isObject(t)){var i=t.stack;r=e+m(i,t)}else r=e+String(t);"function"==typeof o?o(r,n):"function"!=typeof console.log&&"object"!=typeof console.log||console.log(r)}}function H(t,e,n,r){var i=!1;try{"function"==typeof e&&(i=!0,"rejectionHandled"===t?e(r):e(n,r))}catch(t){u.throwLater(t)}"unhandledRejection"===t?A(t,n,r)||i||G(n,"Unhandled rejection "):A(t,r)}function W(t){var e;if("function"==typeof t)e="[function "+(t.name||"anonymous")+"]";else{e=t&&"function"==typeof t.toString?t.toString():c.toString(t);if(/\[object [a-zA-Z0-9$_]+\]/.test(e))try{e=JSON.stringify(t)}catch(t){}0===e.length&&(e="(empty array)")}return"(<"+function(t){if(t.length<41)return t;return t.substr(0,38)+"..."}(e)+">, no stack trace)"}function Z(){return"function"==typeof Q}var Y=function(){return!1},X=/[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;function $(t){var e=t.match(X);if(e)return{fileName:e[1],line:parseInt(e[2],10)}}function J(t){this._parent=t,this._promisesCreated=0;var e=this._length=1+(void 0===t?0:t._length);Q(this,J),e>32&&this.uncycle()}c.inherits(J,Error),r.CapturedTrace=J,J.prototype.uncycle=function(){var t=this._length;if(!(t<2)){for(var e=[],n={},r=0,i=this;void 0!==i;++r)e.push(i),i=i._parent;for(r=(t=this._length=r)-1;r>=0;--r){var a=e[r].stack;void 0===n[a]&&(n[a]=r)}for(r=0;r0&&(e[o-1]._parent=void 0,e[o-1]._length=1),e[r]._parent=void 0,e[r]._length=1;var s=r>0?e[r-1]:this;o=0;--l)e[l]._length=u,u++;return}}}},J.prototype.attachExtraTrace=function(t){if(!t.__stackCleaned__){this.uncycle();for(var e=V(t),n=e.message,r=[e.stack],i=this;void 0!==i;)r.push(q(i.stack.split("\n"))),i=i._parent;!function(t){for(var e=t[0],n=1;n=0;--s)if(r[s]===a){o=s;break}for(s=o;s>=0;--s){var u=r[s];if(e[i]!==u)break;e.pop(),i--}e=r}}(r),function(t){for(var e=0;e=0)return g=/@/,m=e,_=!0,function(t){t.stack=(new Error).stack};try{throw new Error}catch(t){r="stack"in t}return"stack"in i||!r||"number"!=typeof Error.stackTraceLimit?(m=function(t,e){return"string"==typeof t?t:"object"!=typeof e&&"function"!=typeof e||void 0===e.name||void 0===e.message?W(e):e.toString()},null):(g=t,m=e,function(t){Error.stackTraceLimit+=6;try{throw new Error}catch(e){t.stack=e.stack}Error.stackTraceLimit-=6})}();"undefined"!=typeof console&&void 0!==console.warn&&(o=function(t){console.warn(t)},c.isNode&&t.stderr.isTTY?o=function(t,e){var n=e?"":"";console.warn(n+t+"\n")}:c.isNode||"string"!=typeof(new Error).stack||(o=function(t,e){console.warn("%c"+t,e?"color: darkorange":"color: red")}));var K={warnings:w,longStackTraces:!1,cancellation:!1,monitoring:!1};return b&&n.longStackTraces(),{longStackTraces:function(){return K.longStackTraces},warnings:function(){return K.warnings},cancellation:function(){return K.cancellation},monitoring:function(){return K.monitoring},propagateFromFunction:function(){return P},boundValueFunction:function(){return O},checkForgottenReturns:function(t,e,n,r,i){if(void 0===t&&null!==e&&x){if(void 0!==i&&i._returnedNonUndefined())return;if(0==(65535&r._bitField))return;n&&(n+=" ");var a="",o="";if(e._trace){for(var s=e._trace.stack.split("\n"),u=q(s),l=u.length-1;l>=0;--l){var c=u[l];if(!d.test(c)){var f=c.match(v);f&&(a="at "+f[1]+":"+f[2]+":"+f[3]+" ");break}}if(u.length>0){var h=u[0];for(l=0;l0&&(o="\n"+s[l-1]);break}}}var p="a promise was created in a "+n+"handler "+a+"but was not returned from it, see http://goo.gl/rRqMUw"+o;r._warn(p,!0,e)}},setBounds:function(t,e){if(Z()){for(var n,r,i=t.stack.split("\n"),a=e.stack.split("\n"),o=-1,s=-1,u=0;u=s||(Y=function(t){if(p.test(t))return!0;var e=$(t);return!!(e&&e.fileName===n&&o<=e.line&&e.line<=s)})}},warn:z,deprecated:function(t,e){var n=t+" is deprecated and will be removed in a future version.";return e&&(n+=" Use "+e+" instead."),z(n)},CapturedTrace:J,fireDomEvent:E,fireGlobalEvent:S}}},{"./errors":12,"./es5":13,"./util":36}],10:[function(t,e,n){"use strict";e.exports=function(t){function e(){return this.value}function n(){throw this.reason}t.prototype.return=t.prototype.thenReturn=function(n){return n instanceof t&&n.suppressUnhandledRejections(),this._then(e,void 0,void 0,{value:n},void 0)},t.prototype.throw=t.prototype.thenThrow=function(t){return this._then(n,void 0,void 0,{reason:t},void 0)},t.prototype.catchThrow=function(t){if(arguments.length<=1)return this._then(void 0,n,void 0,{reason:t},void 0);var e=arguments[1];return this.caught(t,function(){throw e})},t.prototype.catchReturn=function(n){if(arguments.length<=1)return n instanceof t&&n.suppressUnhandledRejections(),this._then(void 0,e,void 0,{value:n},void 0);var r=arguments[1];r instanceof t&&r.suppressUnhandledRejections();return this.caught(n,function(){return r})}}},{}],11:[function(t,e,n){"use strict";e.exports=function(t,e){var n=t.reduce,r=t.all;function i(){return r(this)}t.prototype.each=function(t){return n(this,t,e,0)._then(i,void 0,void 0,this,void 0)},t.prototype.mapSeries=function(t){return n(this,t,e,e)},t.each=function(t,r){return n(t,r,e,0)._then(i,void 0,void 0,t,void 0)},t.mapSeries=function(t,r){return n(t,r,e,e)}}},{}],12:[function(t,e,n){"use strict";var r,i,a=t("./es5"),o=a.freeze,s=t("./util"),u=s.inherits,l=s.notEnumerableProp;function c(t,e){function n(r){if(!(this instanceof n))return new n(r);l(this,"message","string"==typeof r?r:e),l(this,"name",t),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):Error.call(this)}return u(n,Error),n}var f=c("Warning","warning"),h=c("CancellationError","cancellation error"),p=c("TimeoutError","timeout error"),d=c("AggregateError","aggregate error");try{r=TypeError,i=RangeError}catch(t){r=c("TypeError","type error"),i=c("RangeError","range error")}for(var v="join pop push shift unshift slice filter forEach some every map indexOf lastIndexOf reduce reduceRight sort reverse".split(" "),g=0;g1?t.cancelPromise._reject(e):t.cancelPromise._cancel(),t.cancelPromise=null,!0)}function f(){return p.call(this,this.promise._target()._settledValue())}function h(t){if(!c(this,t))return o.e=t,o}function p(t){var i=this.promise,s=this.handler;if(!this.called){this.called=!0;var u=this.isFinallyHandler()?s.call(i._boundValue()):s.call(i._boundValue(),t);if(u===r)return u;if(void 0!==u){i._setReturnedNonUndefined();var p=n(u,i);if(p instanceof e){if(null!=this.cancelPromise){if(p._isCancelled()){var d=new a("late cancellation observer");return i._attachExtraTrace(d),o.e=d,o}p.isPending()&&p._attachCancellationCallback(new l(this))}return p._then(f,h,void 0,this,void 0)}}}return i.isRejected()?(c(this),o.e=t,o):(c(this),t)}return u.prototype.isFinallyHandler=function(){return 0===this.type},l.prototype._resultCancelled=function(){c(this.finallyHandler)},e.prototype._passThrough=function(t,e,n,r){return"function"!=typeof t?this.then():this._then(n,r,void 0,new u(this,e,t),void 0)},e.prototype.lastly=e.prototype.finally=function(t){return this._passThrough(t,0,p,p)},e.prototype.tap=function(t){return this._passThrough(t,1,p)},e.prototype.tapCatch=function(t){var n=arguments.length;if(1===n)return this._passThrough(t,1,void 0,p);var r,a=new Array(n-1),o=0;for(r=0;r0&&"function"==typeof arguments[e]&&(t=arguments[e]);var r=[].slice.call(arguments);t&&r.pop();var i=new n(r).promise();return void 0!==t?i.spread(t):i}}},{"./util":36}],18:[function(t,e,n){"use strict";e.exports=function(e,n,r,i,a,o){var s=e._getDomain,u=t("./util"),l=u.tryCatch,c=u.errorObj,f=e._async;function h(t,e,n,r){this.constructor$(t),this._promise._captureStackTrace();var i=s();this._callback=null===i?e:u.domainBind(i,e),this._preservedValues=r===a?new Array(this.length()):null,this._limit=n,this._inFlight=0,this._queue=[],f.invoke(this._asyncInit,this,void 0)}function p(t,n,i,a){if("function"!=typeof n)return r("expecting a function but got "+u.classString(n));var o=0;if(void 0!==i){if("object"!=typeof i||null===i)return e.reject(new TypeError("options argument must be an object but it is "+u.classString(i)));if("number"!=typeof i.concurrency)return e.reject(new TypeError("'concurrency' must be a number but it is "+u.classString(i.concurrency)));o=i.concurrency}return new h(t,n,o="number"==typeof o&&isFinite(o)&&o>=1?o:0,a).promise()}u.inherits(h,n),h.prototype._asyncInit=function(){this._init$(void 0,-2)},h.prototype._init=function(){},h.prototype._promiseFulfilled=function(t,n){var r=this._values,a=this.length(),s=this._preservedValues,u=this._limit;if(n<0){if(r[n=-1*n-1]=t,u>=1&&(this._inFlight--,this._drainQueue(),this._isResolved()))return!0}else{if(u>=1&&this._inFlight>=u)return r[n]=t,this._queue.push(n),!1;null!==s&&(s[n]=t);var f=this._promise,h=this._callback,p=f._boundValue();f._pushContext();var d=l(h).call(p,t,n,a),v=f._popContext();if(o.checkForgottenReturns(d,v,null!==s?"Promise.filter":"Promise.map",f),d===c)return this._reject(d.e),!0;var g=i(d,this._promise);if(g instanceof e){var m=(g=g._target())._bitField;if(0==(50397184&m))return u>=1&&this._inFlight++,r[n]=g,g._proxy(this,-1*(n+1)),!1;if(0==(33554432&m))return 0!=(16777216&m)?(this._reject(g._reason()),!0):(this._cancel(),!0);d=g._value()}r[n]=d}return++this._totalResolved>=a&&(null!==s?this._filter(r,s):this._resolve(r),!0)},h.prototype._drainQueue=function(){for(var t=this._queue,e=this._limit,n=this._values;t.length>0&&this._inFlight1){a.deprecated("calling Promise.try with more than 1 argument");var l=arguments[1],c=arguments[2];r=o.isArray(l)?s(t).apply(c,l):s(t).call(c,l)}else r=s(t)();var f=u._popContext();return a.checkForgottenReturns(r,f,"Promise.try",u),u._resolveFromSyncValue(r),u},e.prototype._resolveFromSyncValue=function(t){t===o.errorObj?this._rejectCallback(t.e,!1):this._resolveCallback(t,!0)}}},{"./util":36}],20:[function(t,e,n){"use strict";var r=t("./util"),i=r.maybeWrapAsError,a=t("./errors").OperationalError,o=t("./es5");var s=/^(?:name|message|stack|cause)$/;function u(t){var e;if(function(t){return t instanceof Error&&o.getPrototypeOf(t)===Error.prototype}(t)){(e=new a(t)).name=t.name,e.message=t.message,e.stack=t.stack;for(var n=o.keys(t),i=0;i1){var n,r=new Array(e-1),i=0;for(n=0;n0&&"function"!=typeof t&&"function"!=typeof e){var n=".then() only accepts functions but was passed: "+l.classString(t);arguments.length>1&&(n+=", "+l.classString(e)),this._warn(n)}return this._then(t,e,void 0,void 0,void 0)},C.prototype.done=function(t,e){this._then(t,e,void 0,void 0,void 0)._setIsFinal()},C.prototype.spread=function(t){return"function"!=typeof t?a("expecting a function but got "+l.classString(t)):this.all()._then(t,void 0,void 0,m,void 0)},C.prototype.toJSON=function(){var t={isFulfilled:!1,isRejected:!1,fulfillmentValue:void 0,rejectionReason:void 0};return this.isFulfilled()?(t.fulfillmentValue=this.value(),t.isFulfilled=!0):this.isRejected()&&(t.rejectionReason=this.reason(),t.isRejected=!0),t},C.prototype.all=function(){return arguments.length>0&&this._warn(".all() was passed arguments but it does not take any"),new w(this).promise()},C.prototype.error=function(t){return this.caught(l.originatesFromRejection,t)},C.getNewLibraryCopy=n.exports,C.is=function(t){return t instanceof C},C.fromNode=C.fromCallback=function(t){var e=new C(g);e._captureStackTrace();var n=arguments.length>1&&!!Object(arguments[1]).multiArgs,r=A(t)(j(e,n));return r===T&&e._rejectCallback(r.e,!0),e._isFateSealed()||e._setAsyncGuaranteed(),e},C.all=function(t){return new w(t).promise()},C.cast=function(t){var e=y(t);return e instanceof C||((e=new C(g))._captureStackTrace(),e._setFulfilled(),e._rejectionHandler0=t),e},C.resolve=C.fulfilled=C.cast,C.reject=C.rejected=function(t){var e=new C(g);return e._captureStackTrace(),e._rejectCallback(t,!0),e},C.setScheduler=function(t){if("function"!=typeof t)throw new d("expecting a function but got "+l.classString(t));return h.setScheduler(t)},C.prototype._then=function(t,e,n,r,i){var a=void 0!==i,o=a?i:new C(g),u=this._target(),c=u._bitField;a||(o._propagateFrom(this,3),o._captureStackTrace(),void 0===r&&0!=(2097152&this._bitField)&&(r=0!=(50397184&c)?this._boundValue():u===this?void 0:this._boundTo),this._fireEvent("promiseChained",this,o));var f=s();if(0!=(50397184&c)){var p,d,m=u._settlePromiseCtx;0!=(33554432&c)?(d=u._rejectionHandler0,p=t):0!=(16777216&c)?(d=u._fulfillmentHandler0,p=e,u._unsetRejectionIsUnhandled()):(m=u._settlePromiseLateCancellationObserver,d=new v("late cancellation observer"),u._attachExtraTrace(d),p=e),h.invoke(m,u,{handler:null===f?p:"function"==typeof p&&l.domainBind(f,p),promise:o,receiver:r,value:d})}else u._addCallbacks(t,e,o,r,f);return o},C.prototype._length=function(){return 65535&this._bitField},C.prototype._isFateSealed=function(){return 0!=(117506048&this._bitField)},C.prototype._isFollowing=function(){return 67108864==(67108864&this._bitField)},C.prototype._setLength=function(t){this._bitField=-65536&this._bitField|65535&t},C.prototype._setFulfilled=function(){this._bitField=33554432|this._bitField,this._fireEvent("promiseFulfilled",this)},C.prototype._setRejected=function(){this._bitField=16777216|this._bitField,this._fireEvent("promiseRejected",this)},C.prototype._setFollowing=function(){this._bitField=67108864|this._bitField,this._fireEvent("promiseResolved",this)},C.prototype._setIsFinal=function(){this._bitField=4194304|this._bitField},C.prototype._isFinal=function(){return(4194304&this._bitField)>0},C.prototype._unsetCancelled=function(){this._bitField=-65537&this._bitField},C.prototype._setCancelled=function(){this._bitField=65536|this._bitField,this._fireEvent("promiseCancelled",this)},C.prototype._setWillBeCancelled=function(){this._bitField=8388608|this._bitField},C.prototype._setAsyncGuaranteed=function(){h.hasCustomScheduler()||(this._bitField=134217728|this._bitField)},C.prototype._receiverAt=function(t){var e=0===t?this._receiver0:this[4*t-4+3];if(e!==u)return void 0===e&&this._isBound()?this._boundValue():e},C.prototype._promiseAt=function(t){return this[4*t-4+2]},C.prototype._fulfillmentHandlerAt=function(t){return this[4*t-4+0]},C.prototype._rejectionHandlerAt=function(t){return this[4*t-4+1]},C.prototype._boundValue=function(){},C.prototype._migrateCallback0=function(t){t._bitField;var e=t._fulfillmentHandler0,n=t._rejectionHandler0,r=t._promise0,i=t._receiverAt(0);void 0===i&&(i=u),this._addCallbacks(e,n,r,i,null)},C.prototype._migrateCallbackAt=function(t,e){var n=t._fulfillmentHandlerAt(e),r=t._rejectionHandlerAt(e),i=t._promiseAt(e),a=t._receiverAt(e);void 0===a&&(a=u),this._addCallbacks(n,r,i,a,null)},C.prototype._addCallbacks=function(t,e,n,r,i){var a=this._length();if(a>=65531&&(a=0,this._setLength(0)),0===a)this._promise0=n,this._receiver0=r,"function"==typeof t&&(this._fulfillmentHandler0=null===i?t:l.domainBind(i,t)),"function"==typeof e&&(this._rejectionHandler0=null===i?e:l.domainBind(i,e));else{var o=4*a-4;this[o+2]=n,this[o+3]=r,"function"==typeof t&&(this[o+0]=null===i?t:l.domainBind(i,t)),"function"==typeof e&&(this[o+1]=null===i?e:l.domainBind(i,e))}return this._setLength(a+1),a},C.prototype._proxy=function(t,e){this._addCallbacks(void 0,void 0,e,t,null)},C.prototype._resolveCallback=function(t,e){if(0==(117506048&this._bitField)){if(t===this)return this._rejectCallback(r(),!1);var n=y(t,this);if(!(n instanceof C))return this._fulfill(t);e&&this._propagateFrom(n,2);var i=n._target();if(i!==this){var a=i._bitField;if(0==(50397184&a)){var o=this._length();o>0&&i._migrateCallback0(this);for(var s=1;s>>16)){if(t===this){var n=r();return this._attachExtraTrace(n),this._reject(n)}this._setFulfilled(),this._rejectionHandler0=t,(65535&e)>0&&(0!=(134217728&e)?this._settlePromises():h.settlePromises(this),this._dereferenceTrace())}},C.prototype._reject=function(t){var e=this._bitField;if(!((117506048&e)>>>16)){if(this._setRejected(),this._fulfillmentHandler0=t,this._isFinal())return h.fatalError(t,l.isNode);(65535&e)>0?h.settlePromises(this):this._ensurePossibleRejectionHandled()}},C.prototype._fulfillPromises=function(t,e){for(var n=1;n0){if(0!=(16842752&t)){var n=this._fulfillmentHandler0;this._settlePromise0(this._rejectionHandler0,n,t),this._rejectPromises(e,n)}else{var r=this._rejectionHandler0;this._settlePromise0(this._fulfillmentHandler0,r,t),this._fulfillPromises(e,r)}this._setLength(0)}this._clearCancellationData()},C.prototype._settledValue=function(){var t=this._bitField;return 0!=(33554432&t)?this._rejectionHandler0:0!=(16777216&t)?this._fulfillmentHandler0:void 0},C.defer=C.pending=function(){return k.deprecated("Promise.defer","new Promise"),{promise:new C(g),resolve:M,reject:I}},l.notEnumerableProp(C,"_makeSelfResolutionError",r),e("./method")(C,g,y,a,k),e("./bind")(C,g,y,k),e("./cancel")(C,w,a,k),e("./direct_resolve")(C),e("./synchronous_inspection")(C),e("./join")(C,w,y,g,h,s),C.Promise=C,C.version="3.5.2",e("./map.js")(C,w,a,y,g,k),e("./call_get.js")(C),e("./using.js")(C,a,y,x,g,k),e("./timers.js")(C,g,k),e("./generators.js")(C,a,g,y,o,k),e("./nodeify.js")(C),e("./promisify.js")(C,g),e("./props.js")(C,w,y,a),e("./race.js")(C,g,y,a),e("./reduce.js")(C,w,a,y,g,k),e("./settle.js")(C,w,k),e("./some.js")(C,w,a),e("./filter.js")(C,g),e("./each.js")(C,g),e("./any.js")(C),l.toFastProperties(C),l.toFastProperties(C.prototype),R({a:1}),R({b:2}),R({c:3}),R(1),R(function(){}),R(void 0),R(!1),R(new C(g)),k.setBounds(f.firstLineError,l.lastLineError),C}},{"./any.js":1,"./async":2,"./bind":3,"./call_get.js":5,"./cancel":6,"./catch_filter":7,"./context":8,"./debuggability":9,"./direct_resolve":10,"./each.js":11,"./errors":12,"./es5":13,"./filter.js":14,"./finally":15,"./generators.js":16,"./join":17,"./map.js":18,"./method":19,"./nodeback":20,"./nodeify.js":21,"./promise_array":23,"./promisify.js":24,"./props.js":25,"./race.js":27,"./reduce.js":28,"./settle.js":30,"./some.js":31,"./synchronous_inspection":32,"./thenables":33,"./timers.js":34,"./using.js":35,"./util":36}],23:[function(t,e,n){"use strict";e.exports=function(e,n,r,i,a){var o=t("./util");o.isArray;function s(t){var r=this._promise=new e(n);t instanceof e&&r._propagateFrom(t,3),r._setOnCancel(this),this._values=t,this._length=0,this._totalResolved=0,this._init(void 0,-2)}return o.inherits(s,a),s.prototype.length=function(){return this._length},s.prototype.promise=function(){return this._promise},s.prototype._init=function t(n,a){var s=r(this._values,this._promise);if(s instanceof e){var u=(s=s._target())._bitField;if(this._values=s,0==(50397184&u))return this._promise._setAsyncGuaranteed(),s._then(t,this._reject,void 0,this,a);if(0==(33554432&u))return 0!=(16777216&u)?this._reject(s._reason()):this._cancel();s=s._value()}if(null!==(s=o.asArray(s)))0!==s.length?this._iterate(s):-5===a?this._resolveEmptyArray():this._resolve(function(t){switch(t){case-2:return[];case-3:return{};case-6:return new Map}}(a));else{var l=i("expecting an array or an iterable object but got "+o.classString(s)).reason();this._promise._rejectCallback(l,!1)}},s.prototype._iterate=function(t){var n=this.getActualLength(t.length);this._length=n,this._values=this.shouldCopyValues()?new Array(n):this._values;for(var i=this._promise,a=!1,o=null,s=0;s=this._length&&(this._resolve(this._values),!0)},s.prototype._promiseCancelled=function(){return this._cancel(),!0},s.prototype._promiseRejected=function(t){return this._totalResolved++,this._reject(t),!0},s.prototype._resultCancelled=function(){if(!this._isResolved()){var t=this._values;if(this._cancel(),t instanceof e)t.cancel();else for(var n=0;n=this._length){var n;if(this._isMap)n=function(t){for(var e=new a,n=t.length/2|0,r=0;r>1},e.prototype.props=function(){return f(this)},e.props=function(t){return f(t)}}},{"./es5":13,"./util":36}],26:[function(t,e,n){"use strict";function r(t){this._capacity=t,this._length=0,this._front=0}r.prototype._willBeOverCapacity=function(t){return this._capacity=this._length&&(this._resolve(this._values),!0)},a.prototype._promiseFulfilled=function(t,e){var n=new i;return n._bitField=33554432,n._settledValueField=t,this._promiseResolved(e,n)},a.prototype._promiseRejected=function(t,e){var n=new i;return n._bitField=16777216,n._settledValueField=t,this._promiseResolved(e,n)},e.settle=function(t){return r.deprecated(".settle()",".reflect()"),new a(t).promise()},e.prototype.settle=function(){return e.settle(this)}}},{"./util":36}],31:[function(t,e,n){"use strict";e.exports=function(e,n,r){var i=t("./util"),a=t("./errors").RangeError,o=t("./errors").AggregateError,s=i.isArray,u={};function l(t){this.constructor$(t),this._howMany=0,this._unwrap=!1,this._initialized=!1}function c(t,e){if((0|e)!==e||e<0)return r("expecting a positive integer\n\n See http://goo.gl/MqrFmX\n");var n=new l(t),i=n.promise();return n.setHowMany(e),n.init(),i}i.inherits(l,n),l.prototype._init=function(){if(this._initialized)if(0!==this._howMany){this._init$(void 0,-5);var t=s(this._values);!this._isResolved()&&t&&this._howMany>this._canPossiblyFulfill()&&this._reject(this._getRangeError(this.length()))}else this._resolve([])},l.prototype.init=function(){this._initialized=!0,this._init()},l.prototype.setUnwrap=function(){this._unwrap=!0},l.prototype.howMany=function(){return this._howMany},l.prototype.setHowMany=function(t){this._howMany=t},l.prototype._promiseFulfilled=function(t){return this._addFulfilled(t),this._fulfilled()===this.howMany()&&(this._values.length=this.howMany(),1===this.howMany()&&this._unwrap?this._resolve(this._values[0]):this._resolve(this._values),!0)},l.prototype._promiseRejected=function(t){return this._addRejected(t),this._checkOutcome()},l.prototype._promiseCancelled=function(){return this._values instanceof e||null==this._values?this._cancel():(this._addRejected(u),this._checkOutcome())},l.prototype._checkOutcome=function(){if(this.howMany()>this._canPossiblyFulfill()){for(var t=new o,e=this.length();e0?this._reject(t):this._cancel(),!0}return!1},l.prototype._fulfilled=function(){return this._totalResolved},l.prototype._rejected=function(){return this._values.length-this.length()},l.prototype._addRejected=function(t){this._values.push(t)},l.prototype._addFulfilled=function(t){this._values[this._totalResolved++]=t},l.prototype._canPossiblyFulfill=function(){return this.length()-this._rejected()},l.prototype._getRangeError=function(t){var e="Input array must contain at least "+this._howMany+" items but contains only "+t+" items";return new a(e)},l.prototype._resolveEmptyArray=function(){this._reject(this._getRangeError(0))},e.some=function(t,e){return c(t,e)},e.prototype.some=function(t){return c(this,t)},e._SomePromiseArray=l}},{"./errors":12,"./util":36}],32:[function(t,e,n){"use strict";e.exports=function(t){function e(t){void 0!==t?(t=t._target(),this._bitField=t._bitField,this._settledValueField=t._isFateSealed()?t._settledValue():void 0):(this._bitField=0,this._settledValueField=void 0)}e.prototype._settledValue=function(){return this._settledValueField};var n=e.prototype.value=function(){if(!this.isFulfilled())throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\n\n See http://goo.gl/MqrFmX\n");return this._settledValue()},r=e.prototype.error=e.prototype.reason=function(){if(!this.isRejected())throw new TypeError("cannot get rejection reason of a non-rejected promise\n\n See http://goo.gl/MqrFmX\n");return this._settledValue()},i=e.prototype.isFulfilled=function(){return 0!=(33554432&this._bitField)},a=e.prototype.isRejected=function(){return 0!=(16777216&this._bitField)},o=e.prototype.isPending=function(){return 0==(50397184&this._bitField)},s=e.prototype.isResolved=function(){return 0!=(50331648&this._bitField)};e.prototype.isCancelled=function(){return 0!=(8454144&this._bitField)},t.prototype.__isCancelled=function(){return 65536==(65536&this._bitField)},t.prototype._isCancelled=function(){return this._target().__isCancelled()},t.prototype.isCancelled=function(){return 0!=(8454144&this._target()._bitField)},t.prototype.isPending=function(){return o.call(this._target())},t.prototype.isRejected=function(){return a.call(this._target())},t.prototype.isFulfilled=function(){return i.call(this._target())},t.prototype.isResolved=function(){return s.call(this._target())},t.prototype.value=function(){return n.call(this._target())},t.prototype.reason=function(){var t=this._target();return t._unsetRejectionIsUnhandled(),r.call(t)},t.prototype._value=function(){return this._settledValue()},t.prototype._reason=function(){return this._unsetRejectionIsUnhandled(),this._settledValue()},t.PromiseInspection=e}},{}],33:[function(t,e,n){"use strict";e.exports=function(e,n){var r=t("./util"),i=r.errorObj,a=r.isObject;var o={}.hasOwnProperty;return function(t,s){if(a(t)){if(t instanceof e)return t;var u=function(t){try{return function(t){return t.then}(t)}catch(t){return i.e=t,i}}(t);if(u===i){s&&s._pushContext();var l=e.reject(u.e);return s&&s._popContext(),l}if("function"==typeof u)return function(t){try{return o.call(t,"_promise0")}catch(t){return!1}}(t)?(l=new e(n),t._then(l._fulfill,l._reject,void 0,l,null),l):function(t,a,o){var s=new e(n),u=s;o&&o._pushContext(),s._captureStackTrace(),o&&o._popContext();var l=!0,c=r.tryCatch(a).call(t,function(t){s&&(s._resolveCallback(t),s=null)},function(t){s&&(s._rejectCallback(t,l,!0),s=null)});return l=!1,s&&c===i&&(s._rejectCallback(c.e,!0,!0),s=null),u}(t,u,s)}return t}}},{"./util":36}],34:[function(t,e,n){"use strict";e.exports=function(e,n,r){var i=t("./util"),a=e.TimeoutError;function o(t){this.handle=t}o.prototype._resultCancelled=function(){clearTimeout(this.handle)};var s=function(t){return u(+this).thenReturn(t)},u=e.delay=function(t,i){var a,u;return void 0!==i?(a=e.resolve(i)._then(s,null,null,t,void 0),r.cancellation()&&i instanceof e&&a._setOnCancel(i)):(a=new e(n),u=setTimeout(function(){a._fulfill()},+t),r.cancellation()&&a._setOnCancel(new o(u)),a._captureStackTrace()),a._setAsyncGuaranteed(),a};e.prototype.delay=function(t){return u(t,this)};function l(t){return clearTimeout(this.handle),t}function c(t){throw clearTimeout(this.handle),t}e.prototype.timeout=function(t,e){var n,s;t=+t;var u=new o(setTimeout(function(){n.isPending()&&function(t,e,n){var r;r="string"!=typeof e?e instanceof Error?e:new a("operation timed out"):new a(e),i.markAsOriginatingFromRejection(r),t._attachExtraTrace(r),t._reject(r),null!=n&&n.cancel()}(n,e,s)},t));return r.cancellation()?(s=this.then(),(n=s._then(l,c,void 0,u,void 0))._setOnCancel(u)):n=this._then(l,c,void 0,u,void 0),n}}},{"./util":36}],35:[function(t,e,n){"use strict";e.exports=function(e,n,r,i,a,o){var s=t("./util"),u=t("./errors").TypeError,l=t("./util").inherits,c=s.errorObj,f=s.tryCatch,h={};function p(t){setTimeout(function(){throw t},0)}function d(t,n){var i=0,o=t.length,s=new e(a);return function a(){if(i>=o)return s._fulfill();var u=function(t){var e=r(t);return e!==t&&"function"==typeof t._isDisposable&&"function"==typeof t._getDisposer&&t._isDisposable()&&e._setDisposable(t._getDisposer()),e}(t[i++]);if(u instanceof e&&u._isDisposable()){try{u=r(u._getDisposer().tryDispose(n),t.promise)}catch(t){return p(t)}if(u instanceof e)return u._then(a,p,null,null,null)}a()}(),s}function v(t,e,n){this._data=t,this._promise=e,this._context=n}function g(t,e,n){this.constructor$(t,e,n)}function m(t){return v.isDisposer(t)?(this.resources[this.index]._setDisposable(t),t.promise()):t}function _(t){this.length=t,this.promise=null,this[t-1]=null}v.prototype.data=function(){return this._data},v.prototype.promise=function(){return this._promise},v.prototype.resource=function(){return this.promise().isFulfilled()?this.promise().value():h},v.prototype.tryDispose=function(t){var e=this.resource(),n=this._context;void 0!==n&&n._pushContext();var r=e!==h?this.doDispose(e,t):null;return void 0!==n&&n._popContext(),this._promise._unsetDisposable(),this._data=null,r},v.isDisposer=function(t){return null!=t&&"function"==typeof t.resource&&"function"==typeof t.tryDispose},l(g,v),g.prototype.doDispose=function(t,e){return this.data().call(t,t,e)},_.prototype._resultCancelled=function(){for(var t=this.length,n=0;n0},e.prototype._getDisposer=function(){return this._disposer},e.prototype._unsetDisposable=function(){this._bitField=-131073&this._bitField,this._disposer=void 0},e.prototype.disposer=function(t){if("function"==typeof t)return new g(t,this,i());throw new u}}},{"./errors":12,"./util":36}],36:[function(e,n,i){"use strict";var a=e("./es5"),o="undefined"==typeof navigator,s={e:{}},u,l="undefined"!=typeof self?self:"undefined"!=typeof window?window:void 0!==r?r:void 0!==this?this:null;function c(){try{var t=u;return u=null,t.apply(this,arguments)}catch(t){return s.e=t,s}}function f(t){return u=t,c}var h=function(t,e){var n={}.hasOwnProperty;function r(){for(var r in this.constructor=t,this.constructor$=e,e.prototype)n.call(e.prototype,r)&&"$"!==r.charAt(r.length-1)&&(this[r+"$"]=e.prototype[r])}return r.prototype=e.prototype,t.prototype=new r,t.prototype};function p(t){return null==t||!0===t||!1===t||"string"==typeof t||"number"==typeof t}function d(t){return"function"==typeof t||"object"==typeof t&&null!==t}function v(t){return p(t)?new Error(T(t)):t}function g(t,e){var n,r=t.length,i=new Array(r+1);for(n=0;n1,r=e.length>0&&!(1===e.length&&"constructor"===e[0]),i=b.test(t+"")&&a.names(t).length>0;if(n||r||i)return!0}return!1}catch(t){return!1}}function k(t){function e(){}e.prototype=t;var n=new e;function r(){return typeof n.foo}return r(),r(),t}var E=/^[a-z$_][a-z$_0-9]*$/i;function S(t){return E.test(t)}function j(t,e,n){for(var r=new Array(t),i=0;i10||V[0]>0),q.isNode&&q.toFastProperties(t);try{throw new Error}catch(t){q.lastLineError=t}n.exports=q},{"./es5":13}]},{},[4])(4)}),"undefined"!=typeof window&&null!==window?window.P=window.Promise:"undefined"!=typeof self&&null!==self&&(self.P=self.Promise)}).call(this,t("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},t("timers").setImmediate)},{_process:117,timers:142}],4:[function(t,e,n){},{}],5:[function(t,e,n){"use strict";var r=t("base64-js"),i=t("ieee754");n.Buffer=s,n.SlowBuffer=function(t){+t!=t&&(t=0);return s.alloc(+t)},n.INSPECT_MAX_BYTES=50;var a=2147483647;function o(t){if(t>a)throw new RangeError("Invalid typed array length");var e=new Uint8Array(t);return e.__proto__=s.prototype,e}function s(t,e,n){if("number"==typeof t){if("string"==typeof e)throw new Error("If encoding is specified then the first argument must be a string");return c(t)}return u(t,e,n)}function u(t,e,n){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return U(t)?function(t,e,n){if(e<0||t.byteLength=a)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a.toString(16)+" bytes");return 0|t}function p(t,e){if(s.isBuffer(t))return t.length;if(z(t)||U(t))return t.byteLength;"string"!=typeof t&&(t=""+t);var n=t.length;if(0===n)return 0;for(var r=!1;;)switch(e){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return O(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return D(t).length;default:if(r)return O(t).length;e=(""+e).toLowerCase(),r=!0}}function d(t,e,n){var r=t[e];t[e]=t[n],t[n]=r}function v(t,e,n,r,i){if(0===t.length)return-1;if("string"==typeof n?(r=n,n=0):n>2147483647?n=2147483647:n<-2147483648&&(n=-2147483648),q(n=+n)&&(n=i?0:t.length-1),n<0&&(n=t.length+n),n>=t.length){if(i)return-1;n=t.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof e&&(e=s.from(e,r)),s.isBuffer(e))return 0===e.length?-1:g(t,e,n,r,i);if("number"==typeof e)return e&=255,"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(t,e,n):Uint8Array.prototype.lastIndexOf.call(t,e,n):g(t,[e],n,r,i);throw new TypeError("val must be string, number or Buffer")}function g(t,e,n,r,i){var a,o=1,s=t.length,u=e.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(t.length<2||e.length<2)return-1;o=2,s/=2,u/=2,n/=2}function l(t,e){return 1===o?t[e]:t.readUInt16BE(e*o)}if(i){var c=-1;for(a=n;as&&(n=s-u),a=n;a>=0;a--){for(var f=!0,h=0;hi&&(r=i):r=i;var a=e.length;if(a%2!=0)throw new TypeError("Invalid hex string");r>a/2&&(r=a/2);for(var o=0;o>8,i=n%256,a.push(i),a.push(r);return a}(e,t.length-n),t,n,r)}function k(t,e,n){return 0===e&&n===t.length?r.fromByteArray(t):r.fromByteArray(t.slice(e,n))}function E(t,e,n){n=Math.min(t.length,n);for(var r=[],i=e;i239?4:l>223?3:l>191?2:1;if(i+f<=n)switch(f){case 1:l<128&&(c=l);break;case 2:128==(192&(a=t[i+1]))&&(u=(31&l)<<6|63&a)>127&&(c=u);break;case 3:a=t[i+1],o=t[i+2],128==(192&a)&&128==(192&o)&&(u=(15&l)<<12|(63&a)<<6|63&o)>2047&&(u<55296||u>57343)&&(c=u);break;case 4:a=t[i+1],o=t[i+2],s=t[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&(u=(15&l)<<18|(63&a)<<12|(63&o)<<6|63&s)>65535&&u<1114112&&(c=u)}null===c?(c=65533,f=1):c>65535&&(c-=65536,r.push(c>>>10&1023|55296),c=56320|1023&c),r.push(c),i+=f}return function(t){var e=t.length;if(e<=S)return String.fromCharCode.apply(String,t);var n="",r=0;for(;rthis.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(e>>>=0))return"";for(t||(t="utf8");;)switch(t){case"hex":return A(this,e,n);case"utf8":case"utf-8":return E(this,e,n);case"ascii":return j(this,e,n);case"latin1":case"binary":return T(this,e,n);case"base64":return k(this,e,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return C(this,e,n);default:if(r)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),r=!0}}.apply(this,arguments)},s.prototype.equals=function(t){if(!s.isBuffer(t))throw new TypeError("Argument must be a Buffer");return this===t||0===s.compare(this,t)},s.prototype.inspect=function(){var t="",e=n.INSPECT_MAX_BYTES;return this.length>0&&(t=this.toString("hex",0,e).match(/.{2}/g).join(" "),this.length>e&&(t+=" ... ")),""},s.prototype.compare=function(t,e,n,r,i){if(!s.isBuffer(t))throw new TypeError("Argument must be a Buffer");if(void 0===e&&(e=0),void 0===n&&(n=t?t.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),e<0||n>t.length||r<0||i>this.length)throw new RangeError("out of range index");if(r>=i&&e>=n)return 0;if(r>=i)return-1;if(e>=n)return 1;if(e>>>=0,n>>>=0,r>>>=0,i>>>=0,this===t)return 0;for(var a=i-r,o=n-e,u=Math.min(a,o),l=this.slice(r,i),c=t.slice(e,n),f=0;f>>=0,isFinite(n)?(n>>>=0,void 0===r&&(r="utf8")):(r=n,n=void 0)}var i=this.length-e;if((void 0===n||n>i)&&(n=i),t.length>0&&(n<0||e<0)||e>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var a=!1;;)switch(r){case"hex":return m(this,t,e,n);case"utf8":case"utf-8":return _(this,t,e,n);case"ascii":return y(this,t,e,n);case"latin1":case"binary":return w(this,t,e,n);case"base64":return b(this,t,e,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return x(this,t,e,n);default:if(a)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),a=!0}},s.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var S=4096;function j(t,e,n){var r="";n=Math.min(t.length,n);for(var i=e;ir)&&(n=r);for(var i="",a=e;an)throw new RangeError("Trying to access beyond buffer length")}function I(t,e,n,r,i,a){if(!s.isBuffer(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>i||et.length)throw new RangeError("Index out of range")}function R(t,e,n,r,i,a){if(n+r>t.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function L(t,e,n,r,a){return e=+e,n>>>=0,a||R(t,0,n,4),i.write(t,e,n,r,23,4),n+4}function B(t,e,n,r,a){return e=+e,n>>>=0,a||R(t,0,n,8),i.write(t,e,n,r,52,8),n+8}s.prototype.slice=function(t,e){var n=this.length;t=~~t,e=void 0===e?n:~~e,t<0?(t+=n)<0&&(t=0):t>n&&(t=n),e<0?(e+=n)<0&&(e=0):e>n&&(e=n),e>>=0,e>>>=0,n||M(t,e,this.length);for(var r=this[t],i=1,a=0;++a>>=0,e>>>=0,n||M(t,e,this.length);for(var r=this[t+--e],i=1;e>0&&(i*=256);)r+=this[t+--e]*i;return r},s.prototype.readUInt8=function(t,e){return t>>>=0,e||M(t,1,this.length),this[t]},s.prototype.readUInt16LE=function(t,e){return t>>>=0,e||M(t,2,this.length),this[t]|this[t+1]<<8},s.prototype.readUInt16BE=function(t,e){return t>>>=0,e||M(t,2,this.length),this[t]<<8|this[t+1]},s.prototype.readUInt32LE=function(t,e){return t>>>=0,e||M(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},s.prototype.readUInt32BE=function(t,e){return t>>>=0,e||M(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},s.prototype.readIntLE=function(t,e,n){t>>>=0,e>>>=0,n||M(t,e,this.length);for(var r=this[t],i=1,a=0;++a=(i*=128)&&(r-=Math.pow(2,8*e)),r},s.prototype.readIntBE=function(t,e,n){t>>>=0,e>>>=0,n||M(t,e,this.length);for(var r=e,i=1,a=this[t+--r];r>0&&(i*=256);)a+=this[t+--r]*i;return a>=(i*=128)&&(a-=Math.pow(2,8*e)),a},s.prototype.readInt8=function(t,e){return t>>>=0,e||M(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},s.prototype.readInt16LE=function(t,e){t>>>=0,e||M(t,2,this.length);var n=this[t]|this[t+1]<<8;return 32768&n?4294901760|n:n},s.prototype.readInt16BE=function(t,e){t>>>=0,e||M(t,2,this.length);var n=this[t+1]|this[t]<<8;return 32768&n?4294901760|n:n},s.prototype.readInt32LE=function(t,e){return t>>>=0,e||M(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},s.prototype.readInt32BE=function(t,e){return t>>>=0,e||M(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},s.prototype.readFloatLE=function(t,e){return t>>>=0,e||M(t,4,this.length),i.read(this,t,!0,23,4)},s.prototype.readFloatBE=function(t,e){return t>>>=0,e||M(t,4,this.length),i.read(this,t,!1,23,4)},s.prototype.readDoubleLE=function(t,e){return t>>>=0,e||M(t,8,this.length),i.read(this,t,!0,52,8)},s.prototype.readDoubleBE=function(t,e){return t>>>=0,e||M(t,8,this.length),i.read(this,t,!1,52,8)},s.prototype.writeUIntLE=function(t,e,n,r){(t=+t,e>>>=0,n>>>=0,r)||I(this,t,e,n,Math.pow(2,8*n)-1,0);var i=1,a=0;for(this[e]=255&t;++a>>=0,n>>>=0,r)||I(this,t,e,n,Math.pow(2,8*n)-1,0);var i=n-1,a=1;for(this[e+i]=255&t;--i>=0&&(a*=256);)this[e+i]=t/a&255;return e+n},s.prototype.writeUInt8=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,1,255,0),this[e]=255&t,e+1},s.prototype.writeUInt16LE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,2,65535,0),this[e]=255&t,this[e+1]=t>>>8,e+2},s.prototype.writeUInt16BE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,2,65535,0),this[e]=t>>>8,this[e+1]=255&t,e+2},s.prototype.writeUInt32LE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,4,4294967295,0),this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t,e+4},s.prototype.writeUInt32BE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,4,4294967295,0),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},s.prototype.writeIntLE=function(t,e,n,r){if(t=+t,e>>>=0,!r){var i=Math.pow(2,8*n-1);I(this,t,e,n,i-1,-i)}var a=0,o=1,s=0;for(this[e]=255&t;++a>0)-s&255;return e+n},s.prototype.writeIntBE=function(t,e,n,r){if(t=+t,e>>>=0,!r){var i=Math.pow(2,8*n-1);I(this,t,e,n,i-1,-i)}var a=n-1,o=1,s=0;for(this[e+a]=255&t;--a>=0&&(o*=256);)t<0&&0===s&&0!==this[e+a+1]&&(s=1),this[e+a]=(t/o>>0)-s&255;return e+n},s.prototype.writeInt8=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,1,127,-128),t<0&&(t=255+t+1),this[e]=255&t,e+1},s.prototype.writeInt16LE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,2,32767,-32768),this[e]=255&t,this[e+1]=t>>>8,e+2},s.prototype.writeInt16BE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,2,32767,-32768),this[e]=t>>>8,this[e+1]=255&t,e+2},s.prototype.writeInt32LE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,4,2147483647,-2147483648),this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24,e+4},s.prototype.writeInt32BE=function(t,e,n){return t=+t,e>>>=0,n||I(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},s.prototype.writeFloatLE=function(t,e,n){return L(this,t,e,!0,n)},s.prototype.writeFloatBE=function(t,e,n){return L(this,t,e,!1,n)},s.prototype.writeDoubleLE=function(t,e,n){return B(this,t,e,!0,n)},s.prototype.writeDoubleBE=function(t,e,n){return B(this,t,e,!1,n)},s.prototype.copy=function(t,e,n,r){if(n||(n=0),r||0===r||(r=this.length),e>=t.length&&(e=t.length),e||(e=0),r>0&&r=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),t.length-e=0;--i)t[i+e]=this[i+n];else if(a<1e3)for(i=0;i>>=0,n=void 0===n?this.length:n>>>0,t||(t=0),"number"==typeof t)for(a=e;a55295&&n<57344){if(!i){if(n>56319){(e-=3)>-1&&a.push(239,191,189);continue}if(o+1===r){(e-=3)>-1&&a.push(239,191,189);continue}i=n;continue}if(n<56320){(e-=3)>-1&&a.push(239,191,189),i=n;continue}n=65536+(i-55296<<10|n-56320)}else i&&(e-=3)>-1&&a.push(239,191,189);if(i=null,n<128){if((e-=1)<0)break;a.push(n)}else if(n<2048){if((e-=2)<0)break;a.push(n>>6|192,63&n|128)}else if(n<65536){if((e-=3)<0)break;a.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((e-=4)<0)break;a.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return a}function D(t){return r.toByteArray(function(t){if((t=t.trim().replace(F,"")).length<2)return"";for(;t.length%4!=0;)t+="=";return t}(t))}function N(t,e,n,r){for(var i=0;i=e.length||i>=t.length);++i)e[i+n]=t[i];return i}function U(t){return t instanceof ArrayBuffer||null!=t&&null!=t.constructor&&"ArrayBuffer"===t.constructor.name&&"number"==typeof t.byteLength}function z(t){return"function"==typeof ArrayBuffer.isView&&ArrayBuffer.isView(t)}function q(t){return t!=t}},{"base64-js":1,ieee754:60}],6:[function(t,e,n){(function(n){var r=t("tty"),i=t("./lib/encode"),a=t("stream").Stream,o=e.exports=function(){var t=null;function e(e){if(t)throw new Error("multiple inputs specified");t=e}var i=null;function a(t){if(i)throw new Error("multiple outputs specified");i=t}for(var o=0;o0&&this.down(e),t>0?this.right(t):t<0&&this.left(-t),this},s.prototype.up=function(t){return void 0===t&&(t=1),this.write(i("["+Math.floor(t)+"A")),this},s.prototype.down=function(t){return void 0===t&&(t=1),this.write(i("["+Math.floor(t)+"B")),this},s.prototype.right=function(t){return void 0===t&&(t=1),this.write(i("["+Math.floor(t)+"C")),this},s.prototype.left=function(t){return void 0===t&&(t=1),this.write(i("["+Math.floor(t)+"D")),this},s.prototype.column=function(t){return this.write(i("["+Math.floor(t)+"G")),this},s.prototype.push=function(t){return this.write(i(t?"7":"[s")),this},s.prototype.pop=function(t){return this.write(i(t?"8":"[u")),this},s.prototype.erase=function(t){return"end"===t||"$"===t?this.write(i("[K")):"start"===t||"^"===t?this.write(i("[1K")):"line"===t?this.write(i("[2K")):"down"===t?this.write(i("[J")):"up"===t?this.write(i("[1J")):"screen"===t?this.write(i("[1J")):this.emit("error",new Error("Unknown erase type: "+t)),this},s.prototype.display=function(t){var e={reset:0,bright:1,dim:2,underscore:4,blink:5,reverse:7,hidden:8}[t];return void 0===e&&this.emit("error",new Error("Unknown attribute: "+t)),this.write(i("["+e+"m")),this},s.prototype.foreground=function(t){if("number"==typeof t)(t<0||t>=256)&&this.emit("error",new Error("Color out of range: "+t)),this.write(i("[38;5;"+t+"m"));else{var e={black:30,red:31,green:32,yellow:33,blue:34,magenta:35,cyan:36,white:37}[t.toLowerCase()];e||this.emit("error",new Error("Unknown color: "+t)),this.write(i("["+e+"m"))}return this},s.prototype.background=function(t){if("number"==typeof t)(t<0||t>=256)&&this.emit("error",new Error("Color out of range: "+t)),this.write(i("[48;5;"+t+"m"));else{var e={black:40,red:41,green:42,yellow:43,blue:44,magenta:45,cyan:46,white:47}[t.toLowerCase()];e||this.emit("error",new Error("Unknown color: "+t)),this.write(i("["+e+"m"))}return this},s.prototype.cursor=function(t){return this.write(i(t?"[?25h":"[?25l")),this};var u=o.extractCodes=function(t){for(var e=[],n=-1,r=0;r=0&&e.push(t.slice(n,r)),n=r):n>=0&&r===t.length-1&&e.push(t.slice(n));return e}}).call(this,t("_process"))},{"./lib/encode":7,_process:117,stream:139,tty:143}],7:[function(t,e,n){(function(t){var n=(e.exports=function(e){return new t([27].concat(function t(e){return"string"==typeof e?e.split("").map(n):Array.isArray(e)?e.reduce(function(e,n){return e.concat(t(n))},[]):void 0}(e)))}).ord=function(t){return t.charCodeAt(0)}}).call(this,t("buffer").Buffer)},{buffer:5}],8:[function(t,e,n){(function(n){"use strict";var r=t("readable-stream").Readable,i=t("util");function a(t,e){if(!(this instanceof a))return new a(t,e);r.call(this,e),null!==t&&void 0!==t||(t=String(t)),this._obj=t}e.exports=a,i.inherits(a,r),a.prototype._read=function(t){var e=this._obj;"string"==typeof e?this.push(new n(e)):n.isBuffer(e)?this.push(e):this.push(new n(JSON.stringify(e))),this.push(null)}}).call(this,t("buffer").Buffer)},{buffer:5,"readable-stream":14,util:150}],9:[function(t,e,n){(function(n){e.exports=s;var r=Object.keys||function(t){var e=[];for(var n in t)e.push(n);return e},i=t("core-util-is");i.inherits=t("inherits");var a=t("./_stream_readable"),o=t("./_stream_writable");function s(t){if(!(this instanceof s))return new s(t);a.call(this,t),o.call(this,t),t&&!1===t.readable&&(this.readable=!1),t&&!1===t.writable&&(this.writable=!1),this.allowHalfOpen=!0,t&&!1===t.allowHalfOpen&&(this.allowHalfOpen=!1),this.once("end",u)}function u(){this.allowHalfOpen||this._writableState.ended||n.nextTick(this.end.bind(this))}i.inherits(s,a),function(t,e){for(var n=0,r=t.length;n0?d(t):w(t)}(t,e);else if(e.objectMode||r&&r.length>0)if(e.ended&&!o){var u=new Error("stream.push() after EOF");t.emit("error",u)}else if(e.endEmitted&&o){u=new Error("stream.unshift() after end event");t.emit("error",u)}else!e.decoder||o||a||(r=e.decoder.write(r)),e.length+=e.objectMode?1:r.length,o?e.buffer.unshift(r):(e.reading=!1,e.buffer.push(r)),e.needReadable&&d(t),function(t,e){e.readingMore||(e.readingMore=!0,n.nextTick(function(){!function(t,e){var n=e.length;for(;!e.reading&&!e.flowing&&!e.ended&&e.lengthe.highWaterMark&&(e.highWaterMark=function(t){if(t>=h)t=h;else{t--;for(var e=1;e<32;e<<=1)t|=t>>e;t++}return t}(t)),t>e.length?e.ended?e.length:(e.needReadable=!0,0):t)}function d(t){var e=t._readableState;e.needReadable=!1,e.emittedReadable||(e.emittedReadable=!0,e.sync?n.nextTick(function(){v(t)}):v(t))}function v(t){t.emit("readable")}function g(t){var e,n=t._readableState;function r(t,r,i){!1===t.write(e)&&n.awaitDrain++}for(n.awaitDrain=0;n.pipesCount&&null!==(e=t.read());)if(1===n.pipesCount?r(n.pipes):b(n.pipes,r),t.emit("data",e),n.awaitDrain>0)return;if(0===n.pipesCount)return n.flowing=!1,void(a.listenerCount(t,"data")>0&&_(t));n.ranOut=!0}function m(){this._readableState.ranOut&&(this._readableState.ranOut=!1,g(this))}function _(t,e){if(t._readableState.flowing)throw new Error("Cannot switch to old mode now.");var r=e||!1,i=!1;t.readable=!0,t.pipe=s.prototype.pipe,t.on=t.addListener=s.prototype.on,t.on("readable",function(){var e;for(i=!0;!r&&null!==(e=t.read());)t.emit("data",e);null===e&&(i=!1,t._readableState.needReadable=!0)}),t.pause=function(){r=!0,this.emit("pause")},t.resume=function(){r=!1,i?n.nextTick(function(){t.emit("readable")}):this.read(0),this.emit("resume")},t.emit("readable")}function y(t,e){var n,r=e.buffer,a=e.length,o=!!e.decoder,s=!!e.objectMode;if(0===r.length)return null;if(0===a)n=null;else if(s)n=r.shift();else if(!t||t>=a)n=o?r.join(""):i.concat(r,a),r.length=0;else{if(t0)throw new Error("endReadable called on non-empty stream");!e.endEmitted&&e.calledRead&&(e.ended=!0,n.nextTick(function(){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}))}function b(t,e){for(var n=0,r=t.length;n0)&&(e.emittedReadable=!1),0===t&&e.needReadable&&(e.length>=e.highWaterMark||e.ended))return d(this),null;if(0===(t=p(t,e))&&e.ended)return n=null,e.length>0&&e.decoder&&(n=y(t,e),e.length-=n.length),0===e.length&&w(this),n;var i=e.needReadable;return e.length-t<=e.highWaterMark&&(i=!0),(e.ended||e.reading)&&(i=!1),i&&(e.reading=!0,e.sync=!0,0===e.length&&(e.needReadable=!0),this._read(e.highWaterMark),e.sync=!1),i&&!e.reading&&(t=p(r,e)),null===(n=t>0?y(t,e):null)&&(e.needReadable=!0,t=0),e.length-=t,0!==e.length||e.ended||(e.needReadable=!0),e.ended&&!e.endEmitted&&0===e.length&&w(this),n},c.prototype._read=function(t){this.emit("error",new Error("not implemented"))},c.prototype.pipe=function(t,e){var i=this,o=this._readableState;switch(o.pipesCount){case 0:o.pipes=t;break;case 1:o.pipes=[o.pipes,t];break;default:o.pipes.push(t)}o.pipesCount+=1;var s=(!e||!1!==e.end)&&t!==n.stdout&&t!==n.stderr?l:f;function u(t){t===i&&f()}function l(){t.end()}o.endEmitted?n.nextTick(s):i.once("end",s),t.on("unpipe",u);var c=function(t){return function(){var e=t._readableState;e.awaitDrain--,0===e.awaitDrain&&g(t)}}(i);function f(){t.removeListener("close",p),t.removeListener("finish",d),t.removeListener("drain",c),t.removeListener("error",h),t.removeListener("unpipe",u),i.removeListener("end",l),i.removeListener("end",f),t._writableState&&!t._writableState.needDrain||c()}function h(e){v(),t.removeListener("error",h),0===a.listenerCount(t,"error")&&t.emit("error",e)}function p(){t.removeListener("finish",d),v()}function d(){t.removeListener("close",p),v()}function v(){i.unpipe(t)}return t.on("drain",c),t._events&&t._events.error?r(t._events.error)?t._events.error.unshift(h):t._events.error=[h,t._events.error]:t.on("error",h),t.once("close",p),t.once("finish",d),t.emit("pipe",i),o.flowing||(this.on("readable",m),o.flowing=!0,n.nextTick(function(){g(i)})),t},c.prototype.unpipe=function(t){var e=this._readableState;if(0===e.pipesCount)return this;if(1===e.pipesCount)return t&&t!==e.pipes?this:(t||(t=e.pipes),e.pipes=null,e.pipesCount=0,this.removeListener("readable",m),e.flowing=!1,t&&t.emit("unpipe",this),this);if(!t){var n=e.pipes,r=e.pipesCount;e.pipes=null,e.pipesCount=0,this.removeListener("readable",m),e.flowing=!1;for(var i=0;i0)throw new Error("cwise: pre() block may not reference array args");if(i0)throw new Error("cwise: post() block may not reference array args")}else if("scalar"===a)e.scalarArgs.push(i),e.shimArgs.push("scalar"+i);else if("index"===a){if(e.indexArgs.push(i),i0)throw new Error("cwise: pre() block may not reference array index");if(i0)throw new Error("cwise: post() block may not reference array index")}else if("shape"===a){if(e.shapeArgs.push(i),in.length)throw new Error("cwise: Too many arguments in pre() block");if(e.body.args.length>n.length)throw new Error("cwise: Too many arguments in body() block");if(e.post.args.length>n.length)throw new Error("cwise: Too many arguments in post() block");return e.debug=!!t.printCode||!!t.debug,e.funcName=t.funcName||"cwise",e.blockSize=t.blockSize||64,r(e)}},{"./lib/thunk.js":18}],17:[function(t,e,n){"use strict";var r=t("uniq");function i(t,e,n){var r,i,a=t.length,o=e.arrayArgs.length,s=e.indexArgs.length>0,u=[],l=[],c=0,f=0;for(r=0;r0&&u.push("var "+l.join(",")),r=a-1;r>=0;--r)c=t[r],u.push(["for(i",r,"=0;i",r,"0&&u.push(["index[",f,"]-=s",f].join("")),u.push(["++index[",c,"]"].join(""))),u.push("}")}return u.join("\n")}function a(t,e,n){for(var r=t.body,i=[],a=[],o=0;o0&&_.push("shape=SS.slice(0)"),t.indexArgs.length>0){var y=new Array(n);for(u=0;u0&&m.push("var "+_.join(",")),u=0;u3&&m.push(a(t.pre,t,s));var k=a(t.body,t,s),E=function(t){for(var e=0,n=t[0].length;e0,l=[],c=0;c0;){"].join("")),l.push(["if(j",c,"<",s,"){"].join("")),l.push(["s",e[c],"=j",c].join("")),l.push(["j",c,"=0"].join("")),l.push(["}else{s",e[c],"=",s].join("")),l.push(["j",c,"-=",s,"}"].join("")),u&&l.push(["index[",e[c],"]=j",c].join(""));for(c=0;c3&&m.push(a(t.post,t,s)),t.debug&&console.log("-----Generated cwise routine for ",e,":\n"+m.join("\n")+"\n----------");var S=[t.funcName||"unnamed","_cwise_loop_",o[0].join("s"),"m",E,function(t){for(var e=new Array(t.length),n=!0,r=0;r0&&(n=n&&e[r]===e[r-1])}return n?e[0]:e.join("")}(s)].join("");return new Function(["function ",S,"(",g.join(","),"){",m.join("\n"),"} return ",S].join(""))()}},{uniq:146}],18:[function(t,e,n){"use strict";var r=t("./compile.js");e.exports=function(t){var e=["'use strict'","var CACHED={}"],n=[],i=t.funcName+"_cwise_thunk";e.push(["return function ",i,"(",t.shimArgs.join(","),"){"].join(""));for(var a=[],o=[],s=[["array",t.arrayArgs[0],".shape.slice(",Math.max(0,t.arrayBlockIndices[0]),t.arrayBlockIndices[0]<0?","+t.arrayBlockIndices[0]+")":")"].join("")],u=[],l=[],c=0;c0&&(u.push("array"+t.arrayArgs[0]+".shape.length===array"+f+".shape.length+"+(Math.abs(t.arrayBlockIndices[0])-Math.abs(t.arrayBlockIndices[c]))),l.push("array"+t.arrayArgs[0]+".shape[shapeIndex+"+Math.max(0,t.arrayBlockIndices[0])+"]===array"+f+".shape[shapeIndex+"+Math.max(0,t.arrayBlockIndices[c])+"]"))}for(t.arrayArgs.length>1&&(e.push("if (!("+u.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same dimensionality!')"),e.push("for(var shapeIndex=array"+t.arrayArgs[0]+".shape.length-"+Math.abs(t.arrayBlockIndices[0])+"; shapeIndex--\x3e0;) {"),e.push("if (!("+l.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same shape!')"),e.push("}")),c=0;c0)return function(t,e){var n,r;for(n=new Array(t),r=0;r 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],25:[function(t,e,n){e.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec4 uLens;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 TextureCoord2GLCoord(vec2 textureCoord) {\n\treturn (textureCoord - vec2(0.5, 0.5)) * 2.0;\n}\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord / 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tfloat correctionRadius = 0.5;\n\tfloat distance = sqrt(vPosition.x * vPosition.x + vPosition.y * vPosition.y) / correctionRadius;\n\tfloat theta = 1.0;\n\tif(distance != 0.0){\n\t\ttheta = atan(distance);\n\t}\n\tvec2 vMapping = theta * vPosition.xy;\n\tvMapping = GLCoord2TextureCoord(vMapping);\n\t\t\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],26:[function(t,e,n){e.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec3 uLensS;\nuniform vec2 uLensF;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord * vec2(1.0, -1.0)/ 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tfloat scale = uLensS.z;\n\tvec3 vPos = vPosition;\n\tfloat Fx = uLensF.x;\n\tfloat Fy = uLensF.y;\n\tvec2 vMapping = vPos.xy;\n\tvMapping.x = vMapping.x + ((pow(vPos.y, 2.0)/scale)*vPos.x/scale)*-Fx;\n\tvMapping.y = vMapping.y + ((pow(vPos.x, 2.0)/scale)*vPos.y/scale)*-Fy;\n\tvMapping = vMapping * uLensS.xy;\n\tvMapping = GLCoord2TextureCoord(vMapping/scale);\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t}\n\tgl_FragColor = texture;\n}\n"},{}],27:[function(t,e,n){e.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec4 uLens;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 TextureCoord2GLCoord(vec2 textureCoord) {\n\treturn (textureCoord - vec2(0.5, 0.5)) * 2.0;\n}\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord / 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tvec2 vMapping = vec2(vTextureCoord.x, 1.0 - vTextureCoord.y);\n\tvMapping = TextureCoord2GLCoord(vMapping);\n\t//TODO insert Code\n\tfloat F = uLens.x/ uLens.w;\n\tfloat seta = length(vMapping) / F;\n\tvMapping = sin(seta) * F / length(vMapping) * vMapping;\n\tvMapping *= uLens.w * 1.414;\n\tvMapping = GLCoord2TextureCoord(vMapping);\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],28:[function(t,e,n){e.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec4 uLens;\nuniform vec2 uFov;\nuniform sampler2D uSampler;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvec2 TextureCoord2GLCoord(vec2 textureCoord) {\n\treturn (textureCoord - vec2(0.5, 0.5)) * 2.0;\n}\nvec2 GLCoord2TextureCoord(vec2 glCoord) {\n\treturn glCoord / 2.0 + vec2(0.5, 0.5);\n}\nvoid main(void){\n\tvec2 vMapping = vec2(vTextureCoord.x, 1.0 - vTextureCoord.y);\n\tvMapping = TextureCoord2GLCoord(vMapping);\n\t//TOD insert Code\n\tfloat F = uLens.x/ uLens.w;\n\tfloat seta = length(vMapping) / F;\n\tvMapping = sin(seta) * F / length(vMapping) * vMapping;\n\tvMapping *= uLens.w * 1.414;\n\tvMapping = GLCoord2TextureCoord(vMapping);\n\tvec4 texture = texture2D(uSampler, vMapping);\n\tif(vMapping.x > 0.99 || vMapping.x < 0.01 || vMapping.y > 0.99 || vMapping.y < 0.01){\n\t\ttexture = vec4(0.0, 0.0, 0.0, 1.0);\n\t} \n\tgl_FragColor = texture;\n}\n"},{}],29:[function(t,e,n){e.exports="#ifdef GL_ES\nprecision highp float;\n#endif\nattribute vec3 aVertexPosition;\nattribute vec2 aTextureCoord;\nvarying vec3 vPosition;\nvarying vec2 vTextureCoord;\nvoid main(void){\n\tvPosition = aVertexPosition;\n\tvTextureCoord = aTextureCoord;\n\tgl_Position = vec4(vPosition,1.0);\n}\n"},{}],30:[function(t,e,n){(function(n,r){"use strict";var i=t("path"),a=t("ndarray"),o=t("omggif").GifReader,s=(t("ndarray-pack"),t("through"),t("data-uri-to-buffer"));function u(t,e){var n;try{n=new o(t)}catch(t){return void e(t)}if(n.numFrames()>0){var r=[n.numFrames(),n.height,n.width,4],i=new Uint8Array(r[0]*r[1]*r[2]*r[3]),s=a(i,r);try{for(var u=0;u=0&&(this.dispose=t)},u.prototype.setRepeat=function(t){this.repeat=t},u.prototype.setTransparent=function(t){this.transparent=t},u.prototype.analyzeImage=function(t){this.setImagePixels(this.removeAlphaChannel(t)),this.analyzePixels()},u.prototype.writeImageInfo=function(){this.firstFrame&&(this.writeLSD(),this.writePalette(),this.repeat>=0&&this.writeNetscapeExt()),this.writeGraphicCtrlExt(),this.writeImageDesc(),this.firstFrame||this.writePalette(),this.firstFrame=!1},u.prototype.outputImage=function(){this.writePixels()},u.prototype.addFrame=function(t){this.emit("frame#start"),this.analyzeImage(t),this.writeImageInfo(),this.outputImage(),this.emit("frame#stop")},u.prototype.finish=function(){this.emit("finish#start"),this.writeByte(59),this.emit("finish#stop")},u.prototype.setQuality=function(t){t<1&&(t=1),this.sample=t},u.prototype.writeHeader=function(){this.emit("writeHeader#start"),this.writeUTFBytes("GIF89a"),this.emit("writeHeader#stop")},u.prototype.analyzePixels=function(){var t=this.pixels.length/3;this.indexedPixels=new Uint8Array(t);var e=new a(this.pixels,this.sample);e.buildColormap(),this.colorTab=e.getColormap();for(var n=0,r=0;r>16,n=(65280&t)>>8,r=255&t,i=0,a=16777216,o=this.colorTab.length,s=0;s=0&&(e=7&dispose),e<<=2,this.writeByte(0|e|t),this.writeShort(this.delay),this.writeByte(this.transIndex),this.writeByte(0)},u.prototype.writeImageDesc=function(){this.writeByte(44),this.writeShort(0),this.writeShort(0),this.writeShort(this.width),this.writeShort(this.height),this.firstFrame?this.writeByte(0):this.writeByte(128|this.palSize)},u.prototype.writeLSD=function(){this.writeShort(this.width),this.writeShort(this.height),this.writeByte(240|this.palSize),this.writeByte(0),this.writeByte(0)},u.prototype.writeNetscapeExt=function(){this.writeByte(33),this.writeByte(255),this.writeByte(11),this.writeUTFBytes("NETSCAPE2.0"),this.writeByte(3),this.writeByte(1),this.writeShort(this.repeat),this.writeByte(0)},u.prototype.writePalette=function(){this.writeBytes(this.colorTab);for(var t=768-this.colorTab.length,e=0;e>8&255)},u.prototype.writePixels=function(){new o(this.width,this.height,this.indexedPixels,this.colorDepth).encode(this)},u.prototype.stream=function(){return this},u.ByteCapacitor=s,e.exports=u}).call(this,t("buffer").Buffer)},{"./LZWEncoder.js":33,"./TypedNeuQuant.js":34,assert:41,buffer:5,events:48,"readable-stream":40,util:150}],33:[function(t,e,n){var r=-1,i=12,a=5003,o=[0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535];e.exports=function(t,e,n,s){var u,l,c,f,h,p,d,v,g,m=Math.max(2,s),_=new Uint8Array(256),y=new Int32Array(a),w=new Int32Array(a),b=0,x=0,k=!1;function E(t,e){_[l++]=t,l>=254&&T(e)}function S(t){j(a),x=v+2,k=!0,M(v,t)}function j(t){for(var e=0;e0&&(t.writeByte(l),t.writeBytes(_,0,l),l=0)}function A(t){return(1<0?u|=t<=8;)E(255&u,e),u>>=8,b-=8;if((x>c||k)&&(k?(c=A(p=d),k=!1):c=++p==i?1<0;)E(255&u,e),u>>=8,b-=8;T(e)}}this.encode=function(n){n.writeByte(m),f=t*e,h=0,function(t,e){var n,o,s,u,f,h,m;for(k=!1,c=A(p=d=t),g=1+(v=1<=0){f=h-s,0===s&&(f=1);do{if((s-=f)<0&&(s+=h),y[s]===n){u=w[s];continue t}}while(y[s]>=0)}M(u,e),u=o,x<1<>c,h=u<>3)*(1<l;)u=T[p++],fl&&((s=n[h--])[0]-=u*(s[0]-r)/_,s[1]-=u*(s[1]-a)/_,s[2]-=u*(s[2]-o)/_)}function M(t,e,r){var a,u,p,d,v,g=~(1<<31),m=g,_=-1,y=_;for(a=0;a>s-o))>c,j[a]-=v,S[a]+=v<>3),t=0;t>p;for(j<=1&&(j=0),n=0;n=c&&(I-=c),n++,0===_&&(_=1),n%_==0)for(E-=E/f,(j=(S-=S/v)>>p)<=1&&(j=0),l=0;l>=o,n[t][1]>>=o,n[t][2]>>=o,n[t][3]=t}(),function(){var t,e,r,o,s,u,l=0,c=0;for(t=0;t>1,e=l+1;e>1,e=l+1;e<256;e++)E[e]=a}()},this.getColormap=function(){for(var t=[],e=[],r=0;r=0;)c=u?c=i:(c++,s<0&&(s=-s),(a=o[0]-t)<0&&(a=-a),(s+=a)=0&&((s=e-(o=n[f])[1])>=u?f=-1:(f--,s<0&&(s=-s),(a=o[0]-t)<0&&(a=-a),(s+=a)0)if(e.ended&&!a){var s=new Error("stream.push() after EOF");t.emit("error",s)}else if(e.endEmitted&&a){s=new Error("stream.unshift() after end event");t.emit("error",s)}else!e.decoder||a||i||(r=e.decoder.write(r)),a||(e.reading=!1),e.flowing&&0===e.length&&!e.sync?(t.emit("data",r),t.read(0)):(e.length+=e.objectMode?1:r.length,a?e.buffer.unshift(r):e.buffer.push(r),e.needReadable&&v(t)),function(t,e){e.readingMore||(e.readingMore=!0,n.nextTick(function(){!function(t,e){var n=e.length;for(;!e.reading&&!e.flowing&&!e.ended&&e.lengthe.highWaterMark&&(e.highWaterMark=function(t){if(t>=p)t=p;else{t--;for(var e=1;e<32;e<<=1)t|=t>>e;t++}return t}(t)),t>e.length?e.ended?e.length:(e.needReadable=!0,0):t)}function v(t){var e=t._readableState;e.needReadable=!1,e.emittedReadable||(l("emitReadable",e.flowing),e.emittedReadable=!0,e.sync?n.nextTick(function(){g(t)}):g(t))}function g(t){l("emit readable"),t.emit("readable"),m(t)}function m(t){var e=t._readableState;if(l("flow",e.flowing),e.flowing)do{var n=t.read()}while(null!==n&&e.flowing)}function _(t,e){var n,r=e.buffer,a=e.length,o=!!e.decoder,s=!!e.objectMode;if(0===r.length)return null;if(0===a)n=null;else if(s)n=r.shift();else if(!t||t>=a)n=o?r.join(""):i.concat(r,a),r.length=0;else{if(t0)throw new Error("endReadable called on non-empty stream");e.endEmitted||(e.ended=!0,n.nextTick(function(){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}))}f.prototype.read=function(t){l("read",t);var e=this._readableState,n=t;if((!u.isNumber(t)||t>0)&&(e.emittedReadable=!1),0===t&&e.needReadable&&(e.length>=e.highWaterMark||e.ended))return l("read: emitReadable",e.length,e.ended),0===e.length&&e.ended?y(this):v(this),null;if(0===(t=d(t,e))&&e.ended)return 0===e.length&&y(this),null;var r,i=e.needReadable;return l("need readable",i),(0===e.length||e.length-t0?_(t,e):null,u.isNull(r)&&(e.needReadable=!0,t=0),e.length-=t,0!==e.length||e.ended||(e.needReadable=!0),n!==t&&e.ended&&0===e.length&&y(this),u.isNull(r)||this.emit("data",r),r},f.prototype._read=function(t){this.emit("error",new Error("not implemented"))},f.prototype.pipe=function(t,e){var i=this,o=this._readableState;switch(o.pipesCount){case 0:o.pipes=t;break;case 1:o.pipes=[o.pipes,t];break;default:o.pipes.push(t)}o.pipesCount+=1,l("pipe count=%d opts=%j",o.pipesCount,e);var s=(!e||!1!==e.end)&&t!==n.stdout&&t!==n.stderr?c:h;function u(t){l("onunpipe"),t===i&&h()}function c(){l("onend"),t.end()}o.endEmitted?n.nextTick(s):i.once("end",s),t.on("unpipe",u);var f=function(t){return function(){var e=t._readableState;l("pipeOnDrain",e.awaitDrain),e.awaitDrain&&e.awaitDrain--,0===e.awaitDrain&&a.listenerCount(t,"data")&&(e.flowing=!0,m(t))}}(i);function h(){l("cleanup"),t.removeListener("close",v),t.removeListener("finish",g),t.removeListener("drain",f),t.removeListener("error",d),t.removeListener("unpipe",u),i.removeListener("end",c),i.removeListener("end",h),i.removeListener("data",p),!o.awaitDrain||t._writableState&&!t._writableState.needDrain||f()}function p(e){l("ondata"),!1===t.write(e)&&(l("false write response, pause",i._readableState.awaitDrain),i._readableState.awaitDrain++,i.pause())}function d(e){l("onerror",e),_(),t.removeListener("error",d),0===a.listenerCount(t,"error")&&t.emit("error",e)}function v(){t.removeListener("finish",g),_()}function g(){l("onfinish"),t.removeListener("close",v),_()}function _(){l("unpipe"),i.unpipe(t)}return t.on("drain",f),i.on("data",p),t._events&&t._events.error?r(t._events.error)?t._events.error.unshift(d):t._events.error=[d,t._events.error]:t.on("error",d),t.once("close",v),t.once("finish",g),t.emit("pipe",i),o.flowing||(l("pipe resume"),i.resume()),t},f.prototype.unpipe=function(t){var e=this._readableState;if(0===e.pipesCount)return this;if(1===e.pipesCount)return t&&t!==e.pipes?this:(t||(t=e.pipes),e.pipes=null,e.pipesCount=0,e.flowing=!1,t&&t.emit("unpipe",this),this);if(!t){var n=e.pipes,r=e.pipesCount;e.pipes=null,e.pipesCount=0,e.flowing=!1;for(var i=0;i1){for(var n=[],r=0;r=0;l--)if(c[l]!==f[l])return!1;for(l=c.length-1;l>=0;l--)if(u=c[l],!_(t[u],e[u],n,r))return!1;return!0}(t,e,n,o))}return n?t===e:t==e}function y(t){return"[object Arguments]"==Object.prototype.toString.call(t)}function w(t,e){if(!t||!e)return!1;if("[object RegExp]"==Object.prototype.toString.call(e))return e.test(t);try{if(t instanceof e)return!0}catch(t){}return!Error.isPrototypeOf(e)&&!0===e.call({},t)}function b(t,e,n,r){var i;if("function"!=typeof e)throw new TypeError('"block" argument must be a function');"string"==typeof n&&(r=n,n=null),i=function(t){var e;try{t()}catch(t){e=t}return e}(e),r=(n&&n.name?" ("+n.name+").":".")+(r?" "+r:"."),t&&!i&&g(i,n,"Missing expected exception"+r);var o="string"==typeof r,s=!t&&a.isError(i),u=!t&&i&&!n;if((s&&o&&w(i,n)||u)&&g(i,n,"Got unwanted exception"+r),t&&i&&n&&!w(i,n)||!t&&i)throw i}f.AssertionError=function(t){var e;this.name="AssertionError",this.actual=t.actual,this.expected=t.expected,this.operator=t.operator,t.message?(this.message=t.message,this.generatedMessage=!1):(this.message=d(v((e=this).actual),128)+" "+e.operator+" "+d(v(e.expected),128),this.generatedMessage=!0);var n=t.stackStartFunction||g;if(Error.captureStackTrace)Error.captureStackTrace(this,n);else{var r=new Error;if(r.stack){var i=r.stack,a=p(n),o=i.indexOf("\n"+a);if(o>=0){var s=i.indexOf("\n",o+1);i=i.substring(s+1)}this.stack=i}}},a.inherits(f.AssertionError,Error),f.fail=g,f.ok=m,f.equal=function(t,e,n){t!=e&&g(t,e,n,"==",f.equal)},f.notEqual=function(t,e,n){t==e&&g(t,e,n,"!=",f.notEqual)},f.deepEqual=function(t,e,n){_(t,e,!1)||g(t,e,n,"deepEqual",f.deepEqual)},f.deepStrictEqual=function(t,e,n){_(t,e,!0)||g(t,e,n,"deepStrictEqual",f.deepStrictEqual)},f.notDeepEqual=function(t,e,n){_(t,e,!1)&&g(t,e,n,"notDeepEqual",f.notDeepEqual)},f.notDeepStrictEqual=function t(e,n,r){_(e,n,!0)&&g(e,n,r,"notDeepStrictEqual",t)},f.strictEqual=function(t,e,n){t!==e&&g(t,e,n,"===",f.strictEqual)},f.notStrictEqual=function(t,e,n){t===e&&g(t,e,n,"!==",f.notStrictEqual)},f.throws=function(t,e,n){b(!0,t,e,n)},f.doesNotThrow=function(t,e,n){b(!1,t,e,n)},f.ifError=function(t){if(t)throw t};var x=Object.keys||function(t){var e=[];for(var n in t)o.call(t,n)&&e.push(n);return e}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"util/":44}],42:[function(t,e,n){"function"==typeof Object.create?e.exports=function(t,e){t.super_=e,t.prototype=Object.create(e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}})}:e.exports=function(t,e){t.super_=e;var n=function(){};n.prototype=e.prototype,t.prototype=new n,t.prototype.constructor=t}},{}],43:[function(t,e,n){e.exports=function(t){return t&&"object"==typeof t&&"function"==typeof t.copy&&"function"==typeof t.fill&&"function"==typeof t.readUInt8}},{}],44:[function(t,e,n){(function(e,r){var i=/%[sdj%]/g;n.format=function(t){if(!m(t)){for(var e=[],n=0;n=a)return t;switch(t){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(t){return"[Circular]"}default:return t}}),u=r[n];n=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),d(e)?r.showHidden=e:e&&n._extend(r,e),_(r.showHidden)&&(r.showHidden=!1),_(r.depth)&&(r.depth=2),_(r.colors)&&(r.colors=!1),_(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=u),c(r,t,r.depth)}function u(t,e){var n=s.styles[e];return n?"["+s.colors[n][0]+"m"+t+"["+s.colors[n][1]+"m":t}function l(t,e){return t}function c(t,e,r){if(t.customInspect&&e&&k(e.inspect)&&e.inspect!==n.inspect&&(!e.constructor||e.constructor.prototype!==e)){var i=e.inspect(r,t);return m(i)||(i=c(t,i,r)),i}var a=function(t,e){if(_(e))return t.stylize("undefined","undefined");if(m(e)){var n="'"+JSON.stringify(e).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return t.stylize(n,"string")}if(g(e))return t.stylize(""+e,"number");if(d(e))return t.stylize(""+e,"boolean");if(v(e))return t.stylize("null","null")}(t,e);if(a)return a;var o=Object.keys(e),s=function(t){var e={};return t.forEach(function(t,n){e[t]=!0}),e}(o);if(t.showHidden&&(o=Object.getOwnPropertyNames(e)),x(e)&&(o.indexOf("message")>=0||o.indexOf("description")>=0))return f(e);if(0===o.length){if(k(e)){var u=e.name?": "+e.name:"";return t.stylize("[Function"+u+"]","special")}if(y(e))return t.stylize(RegExp.prototype.toString.call(e),"regexp");if(b(e))return t.stylize(Date.prototype.toString.call(e),"date");if(x(e))return f(e)}var l,w="",E=!1,S=["{","}"];(p(e)&&(E=!0,S=["[","]"]),k(e))&&(w=" [Function"+(e.name?": "+e.name:"")+"]");return y(e)&&(w=" "+RegExp.prototype.toString.call(e)),b(e)&&(w=" "+Date.prototype.toUTCString.call(e)),x(e)&&(w=" "+f(e)),0!==o.length||E&&0!=e.length?r<0?y(e)?t.stylize(RegExp.prototype.toString.call(e),"regexp"):t.stylize("[Object]","special"):(t.seen.push(e),l=E?function(t,e,n,r,i){for(var a=[],o=0,s=e.length;o=0&&0,t+e.replace(/\u001b\[\d\d?m/g,"").length+1},0)>60)return n[0]+(""===e?"":e+"\n ")+" "+t.join(",\n ")+" "+n[1];return n[0]+e+" "+t.join(", ")+" "+n[1]}(l,w,S)):S[0]+w+S[1]}function f(t){return"["+Error.prototype.toString.call(t)+"]"}function h(t,e,n,r,i,a){var o,s,u;if((u=Object.getOwnPropertyDescriptor(e,i)||{value:e[i]}).get?s=u.set?t.stylize("[Getter/Setter]","special"):t.stylize("[Getter]","special"):u.set&&(s=t.stylize("[Setter]","special")),T(r,i)||(o="["+i+"]"),s||(t.seen.indexOf(u.value)<0?(s=v(n)?c(t,u.value,null):c(t,u.value,n-1)).indexOf("\n")>-1&&(s=a?s.split("\n").map(function(t){return" "+t}).join("\n").substr(2):"\n"+s.split("\n").map(function(t){return" "+t}).join("\n")):s=t.stylize("[Circular]","special")),_(o)){if(a&&i.match(/^\d+$/))return s;(o=JSON.stringify(""+i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(o=o.substr(1,o.length-2),o=t.stylize(o,"name")):(o=o.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),o=t.stylize(o,"string"))}return o+": "+s}function p(t){return Array.isArray(t)}function d(t){return"boolean"==typeof t}function v(t){return null===t}function g(t){return"number"==typeof t}function m(t){return"string"==typeof t}function _(t){return void 0===t}function y(t){return w(t)&&"[object RegExp]"===E(t)}function w(t){return"object"==typeof t&&null!==t}function b(t){return w(t)&&"[object Date]"===E(t)}function x(t){return w(t)&&("[object Error]"===E(t)||t instanceof Error)}function k(t){return"function"==typeof t}function E(t){return Object.prototype.toString.call(t)}function S(t){return t<10?"0"+t.toString(10):t.toString(10)}n.debuglog=function(t){if(_(a)&&(a=e.env.NODE_DEBUG||""),t=t.toUpperCase(),!o[t])if(new RegExp("\\b"+t+"\\b","i").test(a)){var r=e.pid;o[t]=function(){var e=n.format.apply(n,arguments);console.error("%s %d: %s",t,r,e)}}else o[t]=function(){};return o[t]},n.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},n.isArray=p,n.isBoolean=d,n.isNull=v,n.isNullOrUndefined=function(t){return null==t},n.isNumber=g,n.isString=m,n.isSymbol=function(t){return"symbol"==typeof t},n.isUndefined=_,n.isRegExp=y,n.isObject=w,n.isDate=b,n.isError=x,n.isFunction=k,n.isPrimitive=function(t){return null===t||"boolean"==typeof t||"number"==typeof t||"string"==typeof t||"symbol"==typeof t||void 0===t},n.isBuffer=t("./support/isBuffer");var j=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function T(t,e){return Object.prototype.hasOwnProperty.call(t,e)}n.log=function(){var t,e;console.log("%s - %s",(t=new Date,e=[S(t.getHours()),S(t.getMinutes()),S(t.getSeconds())].join(":"),[t.getDate(),j[t.getMonth()],e].join(" ")),n.format.apply(n,arguments))},n.inherits=t("inherits"),n._extend=function(t,e){if(!e||!w(e))return t;for(var n=Object.keys(e),r=n.length;r--;)t[n[r]]=e[n[r]];return t}}).call(this,t("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":43,_process:117,inherits:42}],45:[function(t,e,n){(function(e,r){"use strict";var i=t("assert"),a=t("pako/lib/zlib/zstream"),o=t("pako/lib/zlib/deflate.js"),s=t("pako/lib/zlib/inflate.js"),u=t("pako/lib/zlib/constants");for(var l in u)n[l]=u[l];n.NONE=0,n.DEFLATE=1,n.INFLATE=2,n.GZIP=3,n.GUNZIP=4,n.DEFLATERAW=5,n.INFLATERAW=6,n.UNZIP=7;function c(t){if("number"!=typeof t||tn.UNZIP)throw new TypeError("Bad argument");this.dictionary=null,this.err=0,this.flush=0,this.init_done=!1,this.level=0,this.memLevel=0,this.mode=t,this.strategy=0,this.windowBits=0,this.write_in_progress=!1,this.pending_close=!1,this.gzip_id_bytes_read=0}c.prototype.close=function(){this.write_in_progress?this.pending_close=!0:(this.pending_close=!1,i(this.init_done,"close before init"),i(this.mode<=n.UNZIP),this.mode===n.DEFLATE||this.mode===n.GZIP||this.mode===n.DEFLATERAW?o.deflateEnd(this.strm):this.mode!==n.INFLATE&&this.mode!==n.GUNZIP&&this.mode!==n.INFLATERAW&&this.mode!==n.UNZIP||s.inflateEnd(this.strm),this.mode=n.NONE,this.dictionary=null)},c.prototype.write=function(t,e,n,r,i,a,o){return this._write(!0,t,e,n,r,i,a,o)},c.prototype.writeSync=function(t,e,n,r,i,a,o){return this._write(!1,t,e,n,r,i,a,o)},c.prototype._write=function(t,a,o,s,u,l,c,f){if(i.equal(arguments.length,8),i(this.init_done,"write before init"),i(this.mode!==n.NONE,"already finalized"),i.equal(!1,this.write_in_progress,"write already in progress"),i.equal(!1,this.pending_close,"close is pending"),this.write_in_progress=!0,i.equal(!1,void 0===a,"must provide flush value"),this.write_in_progress=!0,a!==n.Z_NO_FLUSH&&a!==n.Z_PARTIAL_FLUSH&&a!==n.Z_SYNC_FLUSH&&a!==n.Z_FULL_FLUSH&&a!==n.Z_FINISH&&a!==n.Z_BLOCK)throw new Error("Invalid flush value");if(null==o&&(o=r.alloc(0),u=0,s=0),this.strm.avail_in=u,this.strm.input=o,this.strm.next_in=s,this.strm.avail_out=f,this.strm.output=l,this.strm.next_out=c,this.flush=a,!t)return this._process(),this._checkError()?this._afterSync():void 0;var h=this;return e.nextTick(function(){h._process(),h._after()}),this},c.prototype._afterSync=function(){var t=this.strm.avail_out,e=this.strm.avail_in;return this.write_in_progress=!1,[e,t]},c.prototype._process=function(){var t=null;switch(this.mode){case n.DEFLATE:case n.GZIP:case n.DEFLATERAW:this.err=o.deflate(this.strm,this.flush);break;case n.UNZIP:switch(this.strm.avail_in>0&&(t=this.strm.next_in),this.gzip_id_bytes_read){case 0:if(null===t)break;if(31!==this.strm.input[t]){this.mode=n.INFLATE;break}if(this.gzip_id_bytes_read=1,t++,1===this.strm.avail_in)break;case 1:if(null===t)break;139===this.strm.input[t]?(this.gzip_id_bytes_read=2,this.mode=n.GUNZIP):this.mode=n.INFLATE;break;default:throw new Error("invalid number of gzip magic number bytes read")}case n.INFLATE:case n.GUNZIP:case n.INFLATERAW:for(this.err=s.inflate(this.strm,this.flush),this.err===n.Z_NEED_DICT&&this.dictionary&&(this.err=s.inflateSetDictionary(this.strm,this.dictionary),this.err===n.Z_OK?this.err=s.inflate(this.strm,this.flush):this.err===n.Z_DATA_ERROR&&(this.err=n.Z_NEED_DICT));this.strm.avail_in>0&&this.mode===n.GUNZIP&&this.err===n.Z_STREAM_END&&0!==this.strm.next_in[0];)this.reset(),this.err=s.inflate(this.strm,this.flush);break;default:throw new Error("Unknown mode "+this.mode)}},c.prototype._checkError=function(){switch(this.err){case n.Z_OK:case n.Z_BUF_ERROR:if(0!==this.strm.avail_out&&this.flush===n.Z_FINISH)return this._error("unexpected end of file"),!1;break;case n.Z_STREAM_END:break;case n.Z_NEED_DICT:return null==this.dictionary?this._error("Missing dictionary"):this._error("Bad dictionary"),!1;default:return this._error("Zlib error"),!1}return!0},c.prototype._after=function(){if(this._checkError()){var t=this.strm.avail_out,e=this.strm.avail_in;this.write_in_progress=!1,this.callback(e,t),this.pending_close&&this.close()}},c.prototype._error=function(t){this.strm.msg&&(t=this.strm.msg),this.onerror(t,this.err),this.write_in_progress=!1,this.pending_close&&this.close()},c.prototype.init=function(t,e,r,a,o){i(4===arguments.length||5===arguments.length,"init(windowBits, level, memLevel, strategy, [dictionary])"),i(t>=8&&t<=15,"invalid windowBits"),i(e>=-1&&e<=9,"invalid compression level"),i(r>=1&&r<=9,"invalid memlevel"),i(a===n.Z_FILTERED||a===n.Z_HUFFMAN_ONLY||a===n.Z_RLE||a===n.Z_FIXED||a===n.Z_DEFAULT_STRATEGY,"invalid strategy"),this._init(e,t,r,a,o),this._setDictionary()},c.prototype.params=function(){throw new Error("deflateParams Not supported")},c.prototype.reset=function(){this._reset(),this._setDictionary()},c.prototype._init=function(t,e,r,i,u){switch(this.level=t,this.windowBits=e,this.memLevel=r,this.strategy=i,this.flush=n.Z_NO_FLUSH,this.err=n.Z_OK,this.mode!==n.GZIP&&this.mode!==n.GUNZIP||(this.windowBits+=16),this.mode===n.UNZIP&&(this.windowBits+=32),this.mode!==n.DEFLATERAW&&this.mode!==n.INFLATERAW||(this.windowBits=-1*this.windowBits),this.strm=new a,this.mode){case n.DEFLATE:case n.GZIP:case n.DEFLATERAW:this.err=o.deflateInit2(this.strm,this.level,n.Z_DEFLATED,this.windowBits,this.memLevel,this.strategy);break;case n.INFLATE:case n.GUNZIP:case n.INFLATERAW:case n.UNZIP:this.err=s.inflateInit2(this.strm,this.windowBits);break;default:throw new Error("Unknown mode "+this.mode)}this.err!==n.Z_OK&&this._error("Init error"),this.dictionary=u,this.write_in_progress=!1,this.init_done=!0},c.prototype._setDictionary=function(){if(null!=this.dictionary){switch(this.err=n.Z_OK,this.mode){case n.DEFLATE:case n.DEFLATERAW:this.err=o.deflateSetDictionary(this.strm,this.dictionary)}this.err!==n.Z_OK&&this._error("Failed to set dictionary")}},c.prototype._reset=function(){switch(this.err=n.Z_OK,this.mode){case n.DEFLATE:case n.DEFLATERAW:case n.GZIP:this.err=o.deflateReset(this.strm);break;case n.INFLATE:case n.INFLATERAW:case n.GUNZIP:this.err=s.inflateReset(this.strm)}this.err!==n.Z_OK&&this._error("Failed to reset stream")},n.Zlib=c}).call(this,t("_process"),t("buffer").Buffer)},{_process:117,assert:41,buffer:5,"pako/lib/zlib/constants":51,"pako/lib/zlib/deflate.js":53,"pako/lib/zlib/inflate.js":55,"pako/lib/zlib/zstream":59}],46:[function(t,e,n){(function(e){"use strict";var r=t("buffer").Buffer,i=t("stream").Transform,a=t("./binding"),o=t("util"),s=t("assert").ok,u=t("buffer").kMaxLength,l="Cannot create final Buffer. It would be larger than 0x"+u.toString(16)+" bytes";a.Z_MIN_WINDOWBITS=8,a.Z_MAX_WINDOWBITS=15,a.Z_DEFAULT_WINDOWBITS=15,a.Z_MIN_CHUNK=64,a.Z_MAX_CHUNK=1/0,a.Z_DEFAULT_CHUNK=16384,a.Z_MIN_MEMLEVEL=1,a.Z_MAX_MEMLEVEL=9,a.Z_DEFAULT_MEMLEVEL=8,a.Z_MIN_LEVEL=-1,a.Z_MAX_LEVEL=9,a.Z_DEFAULT_LEVEL=a.Z_DEFAULT_COMPRESSION;for(var c=Object.keys(a),f=0;f=u?o=new RangeError(l):e=r.concat(i,a),i=[],t.close(),n(o,e)}t.on("error",function(e){t.removeListener("end",s),t.removeListener("readable",o),n(e)}),t.on("end",s),t.end(e),o()}function _(t,e){if("string"==typeof e&&(e=r.from(e)),!r.isBuffer(e))throw new TypeError("Not a string or buffer");var n=t._finishFlushFlag;return t._processChunk(e,n)}function y(t){if(!(this instanceof y))return new y(t);T.call(this,t,a.DEFLATE)}function w(t){if(!(this instanceof w))return new w(t);T.call(this,t,a.INFLATE)}function b(t){if(!(this instanceof b))return new b(t);T.call(this,t,a.GZIP)}function x(t){if(!(this instanceof x))return new x(t);T.call(this,t,a.GUNZIP)}function k(t){if(!(this instanceof k))return new k(t);T.call(this,t,a.DEFLATERAW)}function E(t){if(!(this instanceof E))return new E(t);T.call(this,t,a.INFLATERAW)}function S(t){if(!(this instanceof S))return new S(t);T.call(this,t,a.UNZIP)}function j(t){return t===a.Z_NO_FLUSH||t===a.Z_PARTIAL_FLUSH||t===a.Z_SYNC_FLUSH||t===a.Z_FULL_FLUSH||t===a.Z_FINISH||t===a.Z_BLOCK}function T(t,e){var o=this;if(this._opts=t=t||{},this._chunkSize=t.chunkSize||n.Z_DEFAULT_CHUNK,i.call(this,t),t.flush&&!j(t.flush))throw new Error("Invalid flush flag: "+t.flush);if(t.finishFlush&&!j(t.finishFlush))throw new Error("Invalid flush flag: "+t.finishFlush);if(this._flushFlag=t.flush||a.Z_NO_FLUSH,this._finishFlushFlag=void 0!==t.finishFlush?t.finishFlush:a.Z_FINISH,t.chunkSize&&(t.chunkSizen.Z_MAX_CHUNK))throw new Error("Invalid chunk size: "+t.chunkSize);if(t.windowBits&&(t.windowBitsn.Z_MAX_WINDOWBITS))throw new Error("Invalid windowBits: "+t.windowBits);if(t.level&&(t.leveln.Z_MAX_LEVEL))throw new Error("Invalid compression level: "+t.level);if(t.memLevel&&(t.memLeveln.Z_MAX_MEMLEVEL))throw new Error("Invalid memLevel: "+t.memLevel);if(t.strategy&&t.strategy!=n.Z_FILTERED&&t.strategy!=n.Z_HUFFMAN_ONLY&&t.strategy!=n.Z_RLE&&t.strategy!=n.Z_FIXED&&t.strategy!=n.Z_DEFAULT_STRATEGY)throw new Error("Invalid strategy: "+t.strategy);if(t.dictionary&&!r.isBuffer(t.dictionary))throw new Error("Invalid dictionary: it should be a Buffer instance");this._handle=new a.Zlib(e);var s=this;this._hadError=!1,this._handle.onerror=function(t,e){A(s),s._hadError=!0;var r=new Error(t);r.errno=e,r.code=n.codes[e],s.emit("error",r)};var u=n.Z_DEFAULT_COMPRESSION;"number"==typeof t.level&&(u=t.level);var l=n.Z_DEFAULT_STRATEGY;"number"==typeof t.strategy&&(l=t.strategy),this._handle.init(t.windowBits||n.Z_DEFAULT_WINDOWBITS,u,t.memLevel||n.Z_DEFAULT_MEMLEVEL,l,t.dictionary),this._buffer=r.allocUnsafe(this._chunkSize),this._offset=0,this._level=u,this._strategy=l,this.once("end",this.close),Object.defineProperty(this,"_closed",{get:function(){return!o._handle},configurable:!0,enumerable:!0})}function A(t,n){n&&e.nextTick(n),t._handle&&(t._handle.close(),t._handle=null)}function C(t){t.emit("close")}Object.defineProperty(n,"codes",{enumerable:!0,value:Object.freeze(p),writable:!1}),n.Deflate=y,n.Inflate=w,n.Gzip=b,n.Gunzip=x,n.DeflateRaw=k,n.InflateRaw=E,n.Unzip=S,n.createDeflate=function(t){return new y(t)},n.createInflate=function(t){return new w(t)},n.createDeflateRaw=function(t){return new k(t)},n.createInflateRaw=function(t){return new E(t)},n.createGzip=function(t){return new b(t)},n.createGunzip=function(t){return new x(t)},n.createUnzip=function(t){return new S(t)},n.deflate=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new y(e),t,n)},n.deflateSync=function(t,e){return _(new y(e),t)},n.gzip=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new b(e),t,n)},n.gzipSync=function(t,e){return _(new b(e),t)},n.deflateRaw=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new k(e),t,n)},n.deflateRawSync=function(t,e){return _(new k(e),t)},n.unzip=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new S(e),t,n)},n.unzipSync=function(t,e){return _(new S(e),t)},n.inflate=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new w(e),t,n)},n.inflateSync=function(t,e){return _(new w(e),t)},n.gunzip=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new x(e),t,n)},n.gunzipSync=function(t,e){return _(new x(e),t)},n.inflateRaw=function(t,e,n){return"function"==typeof e&&(n=e,e={}),m(new E(e),t,n)},n.inflateRawSync=function(t,e){return _(new E(e),t)},o.inherits(T,i),T.prototype.params=function(t,r,i){if(tn.Z_MAX_LEVEL)throw new RangeError("Invalid compression level: "+t);if(r!=n.Z_FILTERED&&r!=n.Z_HUFFMAN_ONLY&&r!=n.Z_RLE&&r!=n.Z_FIXED&&r!=n.Z_DEFAULT_STRATEGY)throw new TypeError("Invalid strategy: "+r);if(this._level!==t||this._strategy!==r){var o=this;this.flush(a.Z_SYNC_FLUSH,function(){s(o._handle,"zlib binding closed"),o._handle.params(t,r),o._hadError||(o._level=t,o._strategy=r,i&&i())})}else e.nextTick(i)},T.prototype.reset=function(){return s(this._handle,"zlib binding closed"),this._handle.reset()},T.prototype._flush=function(t){this._transform(r.alloc(0),"",t)},T.prototype.flush=function(t,n){var i=this,o=this._writableState;("function"==typeof t||void 0===t&&!n)&&(n=t,t=a.Z_FULL_FLUSH),o.ended?n&&e.nextTick(n):o.ending?n&&this.once("end",n):o.needDrain?n&&this.once("drain",function(){return i.flush(t,n)}):(this._flushFlag=t,this.write(r.alloc(0),"",n))},T.prototype.close=function(t){A(this,t),e.nextTick(C,this)},T.prototype._transform=function(t,e,n){var i,o=this._writableState,s=(o.ending||o.ended)&&(!t||o.length===t.length);return null===t||r.isBuffer(t)?this._handle?(s?i=this._finishFlushFlag:(i=this._flushFlag,t.length>=o.length&&(this._flushFlag=this._opts.flush||a.Z_NO_FLUSH)),void this._processChunk(t,i,n)):n(new Error("zlib binding closed")):n(new Error("invalid input"))},T.prototype._processChunk=function(t,e,n){var i=t&&t.length,a=this._chunkSize-this._offset,o=0,c=this,f="function"==typeof n;if(!f){var h,p=[],d=0;this.on("error",function(t){h=t}),s(this._handle,"zlib binding closed");do{var v=this._handle.writeSync(e,t,o,i,this._buffer,this._offset,a)}while(!this._hadError&&_(v[0],v[1]));if(this._hadError)throw h;if(d>=u)throw A(this),new RangeError(l);var g=r.concat(p,d);return A(this),g}s(this._handle,"zlib binding closed");var m=this._handle.write(e,t,o,i,this._buffer,this._offset,a);function _(u,l){if(this&&(this.buffer=null,this.callback=null),!c._hadError){var h=a-l;if(s(h>=0,"have should not go down"),h>0){var v=c._buffer.slice(c._offset,c._offset+h);c._offset+=h,f?c.push(v):(p.push(v),d+=v.length)}if((0===l||c._offset>=c._chunkSize)&&(a=c._chunkSize,c._offset=0,c._buffer=r.allocUnsafe(c._chunkSize)),0===l){if(o+=i-u,i=u,!f)return!0;var g=c._handle.write(e,t,o,i,c._buffer,c._offset,c._chunkSize);return g.callback=_,void(g.buffer=t)}if(!f)return!1;n()}}m.buffer=t,m.callback=_},o.inherits(y,T),o.inherits(w,T),o.inherits(b,T),o.inherits(x,T),o.inherits(k,T),o.inherits(E,T),o.inherits(S,T)}).call(this,t("_process"))},{"./binding":45,_process:117,assert:41,buffer:5,stream:139,util:150}],47:[function(t,e,n){arguments[4][4][0].apply(n,arguments)},{dup:4}],48:[function(t,e,n){var r=Object.create||function(t){var e=function(){};return e.prototype=t,new e},i=Object.keys||function(t){var e=[];for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&e.push(n);return n},a=Function.prototype.bind||function(t){var e=this;return function(){return e.apply(t,arguments)}};function o(){this._events&&Object.prototype.hasOwnProperty.call(this,"_events")||(this._events=r(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0}e.exports=o,o.EventEmitter=o,o.prototype._events=void 0,o.prototype._maxListeners=void 0;var s,u=10;try{var l={};Object.defineProperty&&Object.defineProperty(l,"x",{value:0}),s=0===l.x}catch(t){s=!1}function c(t){return void 0===t._maxListeners?o.defaultMaxListeners:t._maxListeners}function f(t,e,n,i){var a,o,s;if("function"!=typeof n)throw new TypeError('"listener" argument must be a function');if((o=t._events)?(o.newListener&&(t.emit("newListener",e,n.listener?n.listener:n),o=t._events),s=o[e]):(o=t._events=r(null),t._eventsCount=0),s){if("function"==typeof s?s=o[e]=i?[n,s]:[s,n]:i?s.unshift(n):s.push(n),!s.warned&&(a=c(t))&&a>0&&s.length>a){s.warned=!0;var u=new Error("Possible EventEmitter memory leak detected. "+s.length+' "'+String(e)+'" listeners added. Use emitter.setMaxListeners() to increase limit.');u.name="MaxListenersExceededWarning",u.emitter=t,u.type=e,u.count=s.length,"object"==typeof console&&console.warn&&console.warn("%s: %s",u.name,u.message)}}else s=o[e]=n,++t._eventsCount;return t}function h(){if(!this.fired)switch(this.target.removeListener(this.type,this.wrapFn),this.fired=!0,arguments.length){case 0:return this.listener.call(this.target);case 1:return this.listener.call(this.target,arguments[0]);case 2:return this.listener.call(this.target,arguments[0],arguments[1]);case 3:return this.listener.call(this.target,arguments[0],arguments[1],arguments[2]);default:for(var t=new Array(arguments.length),e=0;e1&&(e=arguments[1]),e instanceof Error)throw e;var u=new Error('Unhandled "error" event. ('+e+")");throw u.context=e,u}if(!(n=o[t]))return!1;var l="function"==typeof n;switch(r=arguments.length){case 1:!function(t,e,n){if(e)t.call(n);else for(var r=t.length,i=g(t,r),a=0;a=0;o--)if(n[o]===e||n[o].listener===e){s=n[o].listener,a=o;break}if(a<0)return this;0===a?n.shift():function(t,e){for(var n=e,r=n+1,i=t.length;r=0;a--)this.removeListener(t,e[a]);return this},o.prototype.listeners=function(t){return d(this,t,!0)},o.prototype.rawListeners=function(t){return d(this,t,!1)},o.listenerCount=function(t,e){return"function"==typeof t.listenerCount?t.listenerCount(e):v.call(t,e)},o.prototype.listenerCount=v,o.prototype.eventNames=function(){return this._eventsCount>0?Reflect.ownKeys(this._events):[]}},{}],49:[function(t,e,n){"use strict";var r="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Int32Array;function i(t,e){return Object.prototype.hasOwnProperty.call(t,e)}n.assign=function(t){for(var e=Array.prototype.slice.call(arguments,1);e.length;){var n=e.shift();if(n){if("object"!=typeof n)throw new TypeError(n+"must be non-object");for(var r in n)i(n,r)&&(t[r]=n[r])}}return t},n.shrinkBuf=function(t,e){return t.length===e?t:t.subarray?t.subarray(0,e):(t.length=e,t)};var a={arraySet:function(t,e,n,r,i){if(e.subarray&&t.subarray)t.set(e.subarray(n,n+r),i);else for(var a=0;a>>16&65535|0,o=0;0!==n;){n-=o=n>2e3?2e3:n;do{a=a+(i=i+e[r++]|0)|0}while(--o);i%=65521,a%=65521}return i|a<<16|0}},{}],51:[function(t,e,n){"use strict";e.exports={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,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_BUF_ERROR:-5,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,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8}},{}],52:[function(t,e,n){"use strict";var r=function(){for(var t,e=[],n=0;n<256;n++){t=n;for(var r=0;r<8;r++)t=1&t?3988292384^t>>>1:t>>>1;e[n]=t}return e}();e.exports=function(t,e,n,i){var a=r,o=i+n;t^=-1;for(var s=i;s>>8^a[255&(t^e[s])];return-1^t}},{}],53:[function(t,e,n){"use strict";var r,i=t("../utils/common"),a=t("./trees"),o=t("./adler32"),s=t("./crc32"),u=t("./messages"),l=0,c=1,f=3,h=4,p=5,d=0,v=1,g=-2,m=-3,_=-5,y=-1,w=1,b=2,x=3,k=4,E=0,S=2,j=8,T=9,A=15,C=8,M=286,I=30,R=19,L=2*M+1,B=15,F=3,P=258,O=P+F+1,D=32,N=42,U=69,z=73,q=91,V=103,G=113,H=666,W=1,Z=2,Y=3,X=4,$=3;function J(t,e){return t.msg=u[e],e}function Q(t){return(t<<1)-(t>4?9:0)}function K(t){for(var e=t.length;--e>=0;)t[e]=0}function tt(t){var e=t.state,n=e.pending;n>t.avail_out&&(n=t.avail_out),0!==n&&(i.arraySet(t.output,e.pending_buf,e.pending_out,n,t.next_out),t.next_out+=n,e.pending_out+=n,t.total_out+=n,t.avail_out-=n,e.pending-=n,0===e.pending&&(e.pending_out=0))}function et(t,e){a._tr_flush_block(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,tt(t.strm)}function nt(t,e){t.pending_buf[t.pending++]=e}function rt(t,e){t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e}function it(t,e){var n,r,i=t.max_chain_length,a=t.strstart,o=t.prev_length,s=t.nice_match,u=t.strstart>t.w_size-O?t.strstart-(t.w_size-O):0,l=t.window,c=t.w_mask,f=t.prev,h=t.strstart+P,p=l[a+o-1],d=l[a+o];t.prev_length>=t.good_match&&(i>>=2),s>t.lookahead&&(s=t.lookahead);do{if(l[(n=e)+o]===d&&l[n+o-1]===p&&l[n]===l[a]&&l[++n]===l[a+1]){a+=2,n++;do{}while(l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&l[++a]===l[++n]&&ao){if(t.match_start=e,o=r,r>=s)break;p=l[a+o-1],d=l[a+o]}}}while((e=f[e&c])>u&&0!=--i);return o<=t.lookahead?o:t.lookahead}function at(t){var e,n,r,a,u,l,c,f,h,p,d=t.w_size;do{if(a=t.window_size-t.lookahead-t.strstart,t.strstart>=d+(d-O)){i.arraySet(t.window,t.window,d,d,0),t.match_start-=d,t.strstart-=d,t.block_start-=d,e=n=t.hash_size;do{r=t.head[--e],t.head[e]=r>=d?r-d:0}while(--n);e=n=d;do{r=t.prev[--e],t.prev[e]=r>=d?r-d:0}while(--n);a+=d}if(0===t.strm.avail_in)break;if(l=t.strm,c=t.window,f=t.strstart+t.lookahead,h=a,p=void 0,(p=l.avail_in)>h&&(p=h),n=0===p?0:(l.avail_in-=p,i.arraySet(c,l.input,l.next_in,p,f),1===l.state.wrap?l.adler=o(l.adler,c,p,f):2===l.state.wrap&&(l.adler=s(l.adler,c,p,f)),l.next_in+=p,l.total_in+=p,p),t.lookahead+=n,t.lookahead+t.insert>=F)for(u=t.strstart-t.insert,t.ins_h=t.window[u],t.ins_h=(t.ins_h<=F&&(t.ins_h=(t.ins_h<=F)if(r=a._tr_tally(t,t.strstart-t.match_start,t.match_length-F),t.lookahead-=t.match_length,t.match_length<=t.max_lazy_match&&t.lookahead>=F){t.match_length--;do{t.strstart++,t.ins_h=(t.ins_h<=F&&(t.ins_h=(t.ins_h<4096)&&(t.match_length=F-1)),t.prev_length>=F&&t.match_length<=t.prev_length){i=t.strstart+t.lookahead-F,r=a._tr_tally(t,t.strstart-1-t.prev_match,t.prev_length-F),t.lookahead-=t.prev_length-1,t.prev_length-=2;do{++t.strstart<=i&&(t.ins_h=(t.ins_h<15&&(s=2,r-=16),a<1||a>T||n!==j||r<8||r>15||e<0||e>9||o<0||o>k)return J(t,g);8===r&&(r=9);var u=new function(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=j,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new i.Buf16(2*L),this.dyn_dtree=new i.Buf16(2*(2*I+1)),this.bl_tree=new i.Buf16(2*(2*R+1)),K(this.dyn_ltree),K(this.dyn_dtree),K(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new i.Buf16(B+1),this.heap=new i.Buf16(2*M+1),K(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new i.Buf16(2*M+1),K(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0};return t.state=u,u.strm=t,u.wrap=s,u.gzhead=null,u.w_bits=r,u.w_size=1<t.pending_buf_size-5&&(n=t.pending_buf_size-5);;){if(t.lookahead<=1){if(at(t),0===t.lookahead&&e===l)return W;if(0===t.lookahead)break}t.strstart+=t.lookahead,t.lookahead=0;var r=t.block_start+n;if((0===t.strstart||t.strstart>=r)&&(t.lookahead=t.strstart-r,t.strstart=r,et(t,!1),0===t.strm.avail_out))return W;if(t.strstart-t.block_start>=t.w_size-O&&(et(t,!1),0===t.strm.avail_out))return W}return t.insert=0,e===h?(et(t,!0),0===t.strm.avail_out?Y:X):(t.strstart>t.block_start&&(et(t,!1),t.strm.avail_out),W)}),new ut(4,4,8,4,ot),new ut(4,5,16,8,ot),new ut(4,6,32,32,ot),new ut(4,4,16,16,st),new ut(8,16,32,32,st),new ut(8,16,128,128,st),new ut(8,32,128,256,st),new ut(32,128,258,1024,st),new ut(32,258,258,4096,st)],n.deflateInit=function(t,e){return ft(t,e,j,A,C,E)},n.deflateInit2=ft,n.deflateReset=ct,n.deflateResetKeep=lt,n.deflateSetHeader=function(t,e){return t&&t.state?2!==t.state.wrap?g:(t.state.gzhead=e,d):g},n.deflate=function(t,e){var n,i,o,u;if(!t||!t.state||e>p||e<0)return t?J(t,g):g;if(i=t.state,!t.output||!t.input&&0!==t.avail_in||i.status===H&&e!==h)return J(t,0===t.avail_out?_:g);if(i.strm=t,n=i.last_flush,i.last_flush=e,i.status===N)if(2===i.wrap)t.adler=0,nt(i,31),nt(i,139),nt(i,8),i.gzhead?(nt(i,(i.gzhead.text?1:0)+(i.gzhead.hcrc?2:0)+(i.gzhead.extra?4:0)+(i.gzhead.name?8:0)+(i.gzhead.comment?16:0)),nt(i,255&i.gzhead.time),nt(i,i.gzhead.time>>8&255),nt(i,i.gzhead.time>>16&255),nt(i,i.gzhead.time>>24&255),nt(i,9===i.level?2:i.strategy>=b||i.level<2?4:0),nt(i,255&i.gzhead.os),i.gzhead.extra&&i.gzhead.extra.length&&(nt(i,255&i.gzhead.extra.length),nt(i,i.gzhead.extra.length>>8&255)),i.gzhead.hcrc&&(t.adler=s(t.adler,i.pending_buf,i.pending,0)),i.gzindex=0,i.status=U):(nt(i,0),nt(i,0),nt(i,0),nt(i,0),nt(i,0),nt(i,9===i.level?2:i.strategy>=b||i.level<2?4:0),nt(i,$),i.status=G);else{var m=j+(i.w_bits-8<<4)<<8;m|=(i.strategy>=b||i.level<2?0:i.level<6?1:6===i.level?2:3)<<6,0!==i.strstart&&(m|=D),m+=31-m%31,i.status=G,rt(i,m),0!==i.strstart&&(rt(i,t.adler>>>16),rt(i,65535&t.adler)),t.adler=1}if(i.status===U)if(i.gzhead.extra){for(o=i.pending;i.gzindex<(65535&i.gzhead.extra.length)&&(i.pending!==i.pending_buf_size||(i.gzhead.hcrc&&i.pending>o&&(t.adler=s(t.adler,i.pending_buf,i.pending-o,o)),tt(t),o=i.pending,i.pending!==i.pending_buf_size));)nt(i,255&i.gzhead.extra[i.gzindex]),i.gzindex++;i.gzhead.hcrc&&i.pending>o&&(t.adler=s(t.adler,i.pending_buf,i.pending-o,o)),i.gzindex===i.gzhead.extra.length&&(i.gzindex=0,i.status=z)}else i.status=z;if(i.status===z)if(i.gzhead.name){o=i.pending;do{if(i.pending===i.pending_buf_size&&(i.gzhead.hcrc&&i.pending>o&&(t.adler=s(t.adler,i.pending_buf,i.pending-o,o)),tt(t),o=i.pending,i.pending===i.pending_buf_size)){u=1;break}u=i.gzindexo&&(t.adler=s(t.adler,i.pending_buf,i.pending-o,o)),0===u&&(i.gzindex=0,i.status=q)}else i.status=q;if(i.status===q)if(i.gzhead.comment){o=i.pending;do{if(i.pending===i.pending_buf_size&&(i.gzhead.hcrc&&i.pending>o&&(t.adler=s(t.adler,i.pending_buf,i.pending-o,o)),tt(t),o=i.pending,i.pending===i.pending_buf_size)){u=1;break}u=i.gzindexo&&(t.adler=s(t.adler,i.pending_buf,i.pending-o,o)),0===u&&(i.status=V)}else i.status=V;if(i.status===V&&(i.gzhead.hcrc?(i.pending+2>i.pending_buf_size&&tt(t),i.pending+2<=i.pending_buf_size&&(nt(i,255&t.adler),nt(i,t.adler>>8&255),t.adler=0,i.status=G)):i.status=G),0!==i.pending){if(tt(t),0===t.avail_out)return i.last_flush=-1,d}else if(0===t.avail_in&&Q(e)<=Q(n)&&e!==h)return J(t,_);if(i.status===H&&0!==t.avail_in)return J(t,_);if(0!==t.avail_in||0!==i.lookahead||e!==l&&i.status!==H){var y=i.strategy===b?function(t,e){for(var n;;){if(0===t.lookahead&&(at(t),0===t.lookahead)){if(e===l)return W;break}if(t.match_length=0,n=a._tr_tally(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,n&&(et(t,!1),0===t.strm.avail_out))return W}return t.insert=0,e===h?(et(t,!0),0===t.strm.avail_out?Y:X):t.last_lit&&(et(t,!1),0===t.strm.avail_out)?W:Z}(i,e):i.strategy===x?function(t,e){for(var n,r,i,o,s=t.window;;){if(t.lookahead<=P){if(at(t),t.lookahead<=P&&e===l)return W;if(0===t.lookahead)break}if(t.match_length=0,t.lookahead>=F&&t.strstart>0&&(r=s[i=t.strstart-1])===s[++i]&&r===s[++i]&&r===s[++i]){o=t.strstart+P;do{}while(r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&r===s[++i]&&it.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=F?(n=a._tr_tally(t,1,t.match_length-F),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(n=a._tr_tally(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),n&&(et(t,!1),0===t.strm.avail_out))return W}return t.insert=0,e===h?(et(t,!0),0===t.strm.avail_out?Y:X):t.last_lit&&(et(t,!1),0===t.strm.avail_out)?W:Z}(i,e):r[i.level].func(i,e);if(y!==Y&&y!==X||(i.status=H),y===W||y===Y)return 0===t.avail_out&&(i.last_flush=-1),d;if(y===Z&&(e===c?a._tr_align(i):e!==p&&(a._tr_stored_block(i,0,0,!1),e===f&&(K(i.head),0===i.lookahead&&(i.strstart=0,i.block_start=0,i.insert=0))),tt(t),0===t.avail_out))return i.last_flush=-1,d}return e!==h?d:i.wrap<=0?v:(2===i.wrap?(nt(i,255&t.adler),nt(i,t.adler>>8&255),nt(i,t.adler>>16&255),nt(i,t.adler>>24&255),nt(i,255&t.total_in),nt(i,t.total_in>>8&255),nt(i,t.total_in>>16&255),nt(i,t.total_in>>24&255)):(rt(i,t.adler>>>16),rt(i,65535&t.adler)),tt(t),i.wrap>0&&(i.wrap=-i.wrap),0!==i.pending?d:v)},n.deflateEnd=function(t){var e;return t&&t.state?(e=t.state.status)!==N&&e!==U&&e!==z&&e!==q&&e!==V&&e!==G&&e!==H?J(t,g):(t.state=null,e===G?J(t,m):d):g},n.deflateSetDictionary=function(t,e){var n,r,a,s,u,l,c,f,h=e.length;if(!t||!t.state)return g;if(2===(s=(n=t.state).wrap)||1===s&&n.status!==N||n.lookahead)return g;for(1===s&&(t.adler=o(t.adler,e,h,0)),n.wrap=0,h>=n.w_size&&(0===s&&(K(n.head),n.strstart=0,n.block_start=0,n.insert=0),f=new i.Buf8(n.w_size),i.arraySet(f,e,h-n.w_size,n.w_size,0),e=f,h=n.w_size),u=t.avail_in,l=t.next_in,c=t.input,t.avail_in=h,t.next_in=0,t.input=e,at(n);n.lookahead>=F;){r=n.strstart,a=n.lookahead-(F-1);do{n.ins_h=(n.ins_h<>>=w=y>>>24,d-=w,0===(w=y>>>16&255))j[a++]=65535&y;else{if(!(16&w)){if(0==(64&w)){y=v[(65535&y)+(p&(1<>>=w,d-=w),d<15&&(p+=S[r++]<>>=w=y>>>24,d-=w,!(16&(w=y>>>16&255))){if(0==(64&w)){y=g[(65535&y)+(p&(1<u){t.msg="invalid distance too far back",n.mode=30;break t}if(p>>>=w,d-=w,x>(w=a-o)){if((w=x-w)>c&&n.sane){t.msg="invalid distance too far back",n.mode=30;break t}if(k=0,E=h,0===f){if(k+=l-w,w2;)j[a++]=E[k++],j[a++]=E[k++],j[a++]=E[k++],b-=3;b&&(j[a++]=E[k++],b>1&&(j[a++]=E[k++]))}else{k=a-x;do{j[a++]=j[k++],j[a++]=j[k++],j[a++]=j[k++],b-=3}while(b>2);b&&(j[a++]=j[k++],b>1&&(j[a++]=j[k++]))}break}}break}}while(r>3,p&=(1<<(d-=b<<3))-1,t.next_in=r,t.next_out=a,t.avail_in=r>>24&255)+(t>>>8&65280)+((65280&t)<<8)+((255&t)<<24)}function it(t){var e;return t&&t.state?(e=t.state,t.total_in=t.total_out=e.total=0,t.msg="",e.wrap&&(t.adler=1&e.wrap),e.mode=x,e.last=0,e.havedict=0,e.dmax=32768,e.head=null,e.hold=0,e.bits=0,e.lencode=e.lendyn=new r.Buf32(tt),e.distcode=e.distdyn=new r.Buf32(et),e.sane=1,e.back=-1,d):m}function at(t){var e;return t&&t.state?((e=t.state).wsize=0,e.whave=0,e.wnext=0,it(t)):m}function ot(t,e){var n,r;return t&&t.state?(r=t.state,e<0?(n=0,e=-e):(n=1+(e>>4),e<48&&(e&=15)),e&&(e<8||e>15)?m:(null!==r.window&&r.wbits!==e&&(r.window=null),r.wrap=n,r.wbits=e,at(t))):m}function st(t,e){var n,i;return t?(i=new function(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new r.Buf16(320),this.work=new r.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0},t.state=i,i.window=null,(n=ot(t,e))!==d&&(t.state=null),n):m}var ut,lt,ct=!0;function ft(t){if(ct){var e;for(ut=new r.Buf32(512),lt=new r.Buf32(32),e=0;e<144;)t.lens[e++]=8;for(;e<256;)t.lens[e++]=9;for(;e<280;)t.lens[e++]=7;for(;e<288;)t.lens[e++]=8;for(s(l,t.lens,0,288,ut,0,t.work,{bits:9}),e=0;e<32;)t.lens[e++]=5;s(c,t.lens,0,32,lt,0,t.work,{bits:5}),ct=!1}t.lencode=ut,t.lenbits=9,t.distcode=lt,t.distbits=5}function ht(t,e,n,i){var a,o=t.state;return null===o.window&&(o.wsize=1<=o.wsize?(r.arraySet(o.window,e,n-o.wsize,o.wsize,0),o.wnext=0,o.whave=o.wsize):((a=o.wsize-o.wnext)>i&&(a=i),r.arraySet(o.window,e,n-i,a,o.wnext),(i-=a)?(r.arraySet(o.window,e,n-i,i,0),o.wnext=i,o.whave=o.wsize):(o.wnext+=a,o.wnext===o.wsize&&(o.wnext=0),o.whave>>8&255,n.check=a(n.check,Tt,2,0),st=0,ut=0,n.mode=k;break}if(n.flags=0,n.head&&(n.head.done=!1),!(1&n.wrap)||(((255&st)<<8)+(st>>8))%31){t.msg="incorrect header check",n.mode=J;break}if((15&st)!==b){t.msg="unknown compression method",n.mode=J;break}if(ut-=4,xt=8+(15&(st>>>=4)),0===n.wbits)n.wbits=xt;else if(xt>n.wbits){t.msg="invalid window size",n.mode=J;break}n.dmax=1<>8&1),512&n.flags&&(Tt[0]=255&st,Tt[1]=st>>>8&255,n.check=a(n.check,Tt,2,0)),st=0,ut=0,n.mode=E;case E:for(;ut<32;){if(0===at)break t;at--,st+=tt[nt++]<>>8&255,Tt[2]=st>>>16&255,Tt[3]=st>>>24&255,n.check=a(n.check,Tt,4,0)),st=0,ut=0,n.mode=S;case S:for(;ut<16;){if(0===at)break t;at--,st+=tt[nt++]<>8),512&n.flags&&(Tt[0]=255&st,Tt[1]=st>>>8&255,n.check=a(n.check,Tt,2,0)),st=0,ut=0,n.mode=j;case j:if(1024&n.flags){for(;ut<16;){if(0===at)break t;at--,st+=tt[nt++]<>>8&255,n.check=a(n.check,Tt,2,0)),st=0,ut=0}else n.head&&(n.head.extra=null);n.mode=T;case T:if(1024&n.flags&&((pt=n.length)>at&&(pt=at),pt&&(n.head&&(xt=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),r.arraySet(n.head.extra,tt,nt,pt,xt)),512&n.flags&&(n.check=a(n.check,tt,pt,nt)),at-=pt,nt+=pt,n.length-=pt),n.length))break t;n.length=0,n.mode=A;case A:if(2048&n.flags){if(0===at)break t;pt=0;do{xt=tt[nt+pt++],n.head&&xt&&n.length<65536&&(n.head.name+=String.fromCharCode(xt))}while(xt&&pt>9&1,n.head.done=!0),t.adler=n.check=0,n.mode=L;break;case I:for(;ut<32;){if(0===at)break t;at--,st+=tt[nt++]<>>=7&ut,ut-=7&ut,n.mode=Y;break}for(;ut<3;){if(0===at)break t;at--,st+=tt[nt++]<>>=1)){case 0:n.mode=F;break;case 1:if(ft(n),n.mode=z,e===p){st>>>=2,ut-=2;break t}break;case 2:n.mode=D;break;case 3:t.msg="invalid block type",n.mode=J}st>>>=2,ut-=2;break;case F:for(st>>>=7&ut,ut-=7&ut;ut<32;){if(0===at)break t;at--,st+=tt[nt++]<>>16^65535)){t.msg="invalid stored block lengths",n.mode=J;break}if(n.length=65535&st,st=0,ut=0,n.mode=P,e===p)break t;case P:n.mode=O;case O:if(pt=n.length){if(pt>at&&(pt=at),pt>ot&&(pt=ot),0===pt)break t;r.arraySet(et,tt,nt,pt,it),at-=pt,nt+=pt,ot-=pt,it+=pt,n.length-=pt;break}n.mode=L;break;case D:for(;ut<14;){if(0===at)break t;at--,st+=tt[nt++]<>>=5,ut-=5,n.ndist=1+(31&st),st>>>=5,ut-=5,n.ncode=4+(15&st),st>>>=4,ut-=4,n.nlen>286||n.ndist>30){t.msg="too many length or distance symbols",n.mode=J;break}n.have=0,n.mode=N;case N:for(;n.have>>=3,ut-=3}for(;n.have<19;)n.lens[At[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,Et={bits:n.lenbits},kt=s(u,n.lens,0,19,n.lencode,0,n.work,Et),n.lenbits=Et.bits,kt){t.msg="invalid code lengths set",n.mode=J;break}n.have=0,n.mode=U;case U:for(;n.have>>16&255,_t=65535&jt,!((gt=jt>>>24)<=ut);){if(0===at)break t;at--,st+=tt[nt++]<>>=gt,ut-=gt,n.lens[n.have++]=_t;else{if(16===_t){for(St=gt+2;ut>>=gt,ut-=gt,0===n.have){t.msg="invalid bit length repeat",n.mode=J;break}xt=n.lens[n.have-1],pt=3+(3&st),st>>>=2,ut-=2}else if(17===_t){for(St=gt+3;ut>>=gt)),st>>>=3,ut-=3}else{for(St=gt+7;ut>>=gt)),st>>>=7,ut-=7}if(n.have+pt>n.nlen+n.ndist){t.msg="invalid bit length repeat",n.mode=J;break}for(;pt--;)n.lens[n.have++]=xt}}if(n.mode===J)break;if(0===n.lens[256]){t.msg="invalid code -- missing end-of-block",n.mode=J;break}if(n.lenbits=9,Et={bits:n.lenbits},kt=s(l,n.lens,0,n.nlen,n.lencode,0,n.work,Et),n.lenbits=Et.bits,kt){t.msg="invalid literal/lengths set",n.mode=J;break}if(n.distbits=6,n.distcode=n.distdyn,Et={bits:n.distbits},kt=s(c,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,Et),n.distbits=Et.bits,kt){t.msg="invalid distances set",n.mode=J;break}if(n.mode=z,e===p)break t;case z:n.mode=q;case q:if(at>=6&&ot>=258){t.next_out=it,t.avail_out=ot,t.next_in=nt,t.avail_in=at,n.hold=st,n.bits=ut,o(t,ct),it=t.next_out,et=t.output,ot=t.avail_out,nt=t.next_in,tt=t.input,at=t.avail_in,st=n.hold,ut=n.bits,n.mode===L&&(n.back=-1);break}for(n.back=0;mt=(jt=n.lencode[st&(1<>>16&255,_t=65535&jt,!((gt=jt>>>24)<=ut);){if(0===at)break t;at--,st+=tt[nt++]<>yt)])>>>16&255,_t=65535&jt,!(yt+(gt=jt>>>24)<=ut);){if(0===at)break t;at--,st+=tt[nt++]<>>=yt,ut-=yt,n.back+=yt}if(st>>>=gt,ut-=gt,n.back+=gt,n.length=_t,0===mt){n.mode=Z;break}if(32&mt){n.back=-1,n.mode=L;break}if(64&mt){t.msg="invalid literal/length code",n.mode=J;break}n.extra=15&mt,n.mode=V;case V:if(n.extra){for(St=n.extra;ut>>=n.extra,ut-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=G;case G:for(;mt=(jt=n.distcode[st&(1<>>16&255,_t=65535&jt,!((gt=jt>>>24)<=ut);){if(0===at)break t;at--,st+=tt[nt++]<>yt)])>>>16&255,_t=65535&jt,!(yt+(gt=jt>>>24)<=ut);){if(0===at)break t;at--,st+=tt[nt++]<>>=yt,ut-=yt,n.back+=yt}if(st>>>=gt,ut-=gt,n.back+=gt,64&mt){t.msg="invalid distance code",n.mode=J;break}n.offset=_t,n.extra=15&mt,n.mode=H;case H:if(n.extra){for(St=n.extra;ut>>=n.extra,ut-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){t.msg="invalid distance too far back",n.mode=J;break}n.mode=W;case W:if(0===ot)break t;if(pt=ct-ot,n.offset>pt){if((pt=n.offset-pt)>n.whave&&n.sane){t.msg="invalid distance too far back",n.mode=J;break}pt>n.wnext?(pt-=n.wnext,dt=n.wsize-pt):dt=n.wnext-pt,pt>n.length&&(pt=n.length),vt=n.window}else vt=et,dt=it-n.offset,pt=n.length;pt>ot&&(pt=ot),ot-=pt,n.length-=pt;do{et[it++]=vt[dt++]}while(--pt);0===n.length&&(n.mode=q);break;case Z:if(0===ot)break t;et[it++]=n.length,ot--,n.mode=q;break;case Y:if(n.wrap){for(;ut<32;){if(0===at)break t;at--,st|=tt[nt++]<=1&&0===F[j];j--);if(T>j&&(T=j),0===j)return l[c++]=20971520,l[c++]=20971520,h.bits=1,0;for(S=1;S0&&(0===t||1!==j))return-1;for(P[1]=0,k=1;k<15;k++)P[k+1]=P[k]+F[k];for(E=0;E852||2===t&&I>592)return 1;for(;;){y=k-C,f[E]<_?(w=0,b=f[E]):f[E]>_?(w=O[D+f[E]],b=L[B+f[E]]):(w=96,b=0),p=1<>C)+(d-=p)]=y<<24|w<<16|b|0}while(0!==d);for(p=1<>=1;if(0!==p?(R&=p-1,R+=p):R=0,E++,0==--F[k]){if(k===j)break;k=e[n+f[E]]}if(k>T&&(R&g)!==v){for(0===C&&(C=T),m+=S,M=1<<(A=k-C);A+C852||2===t&&I>592)return 1;l[v=R&g]=T<<24|A<<16|m-c|0}}return 0!==R&&(l[m+R]=k-C<<24|64<<16|0),h.bits=T,0}},{"../utils/common":49}],57:[function(t,e,n){"use strict";e.exports={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"}},{}],58:[function(t,e,n){"use strict";var r=t("../utils/common"),i=4,a=0,o=1,s=2;function u(t){for(var e=t.length;--e>=0;)t[e]=0}var l=0,c=1,f=2,h=29,p=256,d=p+1+h,v=30,g=19,m=2*d+1,_=15,y=16,w=7,b=256,x=16,k=17,E=18,S=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],j=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],T=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],A=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],C=new Array(2*(d+2));u(C);var M=new Array(2*v);u(M);var I=new Array(512);u(I);var R=new Array(256);u(R);var L=new Array(h);u(L);var B,F,P,O=new Array(v);function D(t,e,n,r,i){this.static_tree=t,this.extra_bits=e,this.extra_base=n,this.elems=r,this.max_length=i,this.has_stree=t&&t.length}function N(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}function U(t){return t<256?I[t]:I[256+(t>>>7)]}function z(t,e){t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255}function q(t,e,n){t.bi_valid>y-n?(t.bi_buf|=e<>y-t.bi_valid,t.bi_valid+=n-y):(t.bi_buf|=e<>>=1,n<<=1}while(--e>0);return n>>>1}function H(t,e,n){var r,i,a=new Array(_+1),o=0;for(r=1;r<=_;r++)a[r]=o=o+n[r-1]<<1;for(i=0;i<=e;i++){var s=t[2*i+1];0!==s&&(t[2*i]=G(a[s]++,s))}}function W(t){var e;for(e=0;e8?z(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0}function Y(t,e,n,r){var i=2*e,a=2*n;return t[i]>1;n>=1;n--)X(t,a,n);i=u;do{n=t.heap[1],t.heap[1]=t.heap[t.heap_len--],X(t,a,1),r=t.heap[1],t.heap[--t.heap_max]=n,t.heap[--t.heap_max]=r,a[2*i]=a[2*n]+a[2*r],t.depth[i]=(t.depth[n]>=t.depth[r]?t.depth[n]:t.depth[r])+1,a[2*n+1]=a[2*r+1]=i,t.heap[1]=i++,X(t,a,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],function(t,e){var n,r,i,a,o,s,u=e.dyn_tree,l=e.max_code,c=e.stat_desc.static_tree,f=e.stat_desc.has_stree,h=e.stat_desc.extra_bits,p=e.stat_desc.extra_base,d=e.stat_desc.max_length,v=0;for(a=0;a<=_;a++)t.bl_count[a]=0;for(u[2*t.heap[t.heap_max]+1]=0,n=t.heap_max+1;nd&&(a=d,v++),u[2*r+1]=a,r>l||(t.bl_count[a]++,o=0,r>=p&&(o=h[r-p]),s=u[2*r],t.opt_len+=s*(a+o),f&&(t.static_len+=s*(c[2*r+1]+o)));if(0!==v){do{for(a=d-1;0===t.bl_count[a];)a--;t.bl_count[a]--,t.bl_count[a+1]+=2,t.bl_count[d]--,v-=2}while(v>0);for(a=d;0!==a;a--)for(r=t.bl_count[a];0!==r;)(i=t.heap[--n])>l||(u[2*i+1]!==a&&(t.opt_len+=(a-u[2*i+1])*u[2*i],u[2*i+1]=a),r--)}}(t,e),H(a,l,t.bl_count)}function Q(t,e,n){var r,i,a=-1,o=e[1],s=0,u=7,l=4;for(0===o&&(u=138,l=3),e[2*(n+1)+1]=65535,r=0;r<=n;r++)i=o,o=e[2*(r+1)+1],++s>=7;r0?(t.strm.data_type===s&&(t.strm.data_type=function(t){var e,n=4093624447;for(e=0;e<=31;e++,n>>>=1)if(1&n&&0!==t.dyn_ltree[2*e])return a;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return o;for(e=32;e=3&&0===t.bl_tree[2*A[e]+1];e--);return t.opt_len+=3*(e+1)+5+5+4,e}(t),u=t.opt_len+3+7>>>3,(l=t.static_len+3+7>>>3)<=u&&(u=l)):u=l=n+5,n+4<=u&&-1!==e?et(t,e,n,r):t.strategy===i||l===u?(q(t,(c<<1)+(r?1:0),3),$(t,C,M)):(q(t,(f<<1)+(r?1:0),3),function(t,e,n,r){var i;for(q(t,e-257,5),q(t,n-1,5),q(t,r-4,4),i=0;i>>8&255,t.pending_buf[t.d_buf+2*t.last_lit+1]=255&e,t.pending_buf[t.l_buf+t.last_lit]=255&n,t.last_lit++,0===e?t.dyn_ltree[2*n]++:(t.matches++,e--,t.dyn_ltree[2*(R[n]+p+1)]++,t.dyn_dtree[2*U(e)]++),t.last_lit===t.lit_bufsize-1},n._tr_align=function(t){q(t,c<<1,3),V(t,b,C),function(t){16===t.bi_valid?(z(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)}(t)}},{"../utils/common":49}],59:[function(t,e,n){"use strict";e.exports=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}},{}],60:[function(t,e,n){n.read=function(t,e,n,r,i){var a,o,s=8*i-r-1,u=(1<>1,c=-7,f=n?i-1:0,h=n?-1:1,p=t[e+f];for(f+=h,a=p&(1<<-c)-1,p>>=-c,c+=s;c>0;a=256*a+t[e+f],f+=h,c-=8);for(o=a&(1<<-c)-1,a>>=-c,c+=r;c>0;o=256*o+t[e+f],f+=h,c-=8);if(0===a)a=1-l;else{if(a===u)return o?NaN:1/0*(p?-1:1);o+=Math.pow(2,r),a-=l}return(p?-1:1)*o*Math.pow(2,a-r)},n.write=function(t,e,n,r,i,a){var o,s,u,l=8*a-i-1,c=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=r?0:a-1,d=r?1:-1,v=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,o=c):(o=Math.floor(Math.log(e)/Math.LN2),e*(u=Math.pow(2,-o))<1&&(o--,u*=2),(e+=o+f>=1?h/u:h*Math.pow(2,1-f))*u>=2&&(o++,u/=2),o+f>=c?(s=0,o=c):o+f>=1?(s=(e*u-1)*Math.pow(2,i),o+=f):(s=e*Math.pow(2,f-1)*Math.pow(2,i),o=0));i>=8;t[n+p]=255&s,p+=d,s/=256,i-=8);for(o=o<0;t[n+p]=255&o,p+=d,o/=256,l-=8);t[n+p-d]|=128*v}},{}],61:[function(t,e,n){e.exports=[function(t,e){return{options:t,draw:function(e,n,r){r.stop(!0),r.overrideFlag=!0;var i=this;return e.pixelManipulation({output:function(t,e,n){i.output={src:e,format:n}},changePixel:function(t,e,n,r){return[255-t,255-e,255-n,r]},format:e.format,image:t.image,inBrowser:t.inBrowser,callback:n})},output:void 0,UI:e}},{name:"Invert",description:"Inverts the image.",inputs:{}}]},{}],62:[function(t,e,n){"use strict";var r=t("underscore"),i=e.exports={Bitmap:t("./lib/bitmap")};r.extend(i,t("./lib/enums"))},{"./lib/bitmap":63,"./lib/enums":64,underscore:145}],63:[function(t,e,n){(function(n){"use strict";var r=t("fs"),i=(t("underscore"),t("bluebird")),a=t("jpeg-js"),o=t("node-png").PNG,s=t("./enums"),u=t("./utils"),l=t("./resize"),c={r:0,g:0,b:0,a:0},f=e.exports=function(t){t&&(t instanceof f?this._data={data:new n(t.data.data),width:t.width,height:t.height}:t.data?this._data=t:t.width&&t.height&&(this._data={data:new n(4*t.width*t.height),width:t.width,height:t.height},t.color&&this._fill(t.color)))};f.prototype={get width(){return this._data.width},get height(){return this._data.height},attach:function(t){var e=this._data;return this._data=t,e},detach:function(){var t=this._data;return delete this._data,t},_deduceFileType:function(t){if(!t)throw new Error("Can't determine image type");switch(t.substr(-4).toLowerCase()){case".jpg":return s.ImageType.JPG;case".png":return s.ImageType.PNG}if(".jpeg"==t.substr(-5).toLowerCase())return s.ImageType.JPG;throw new Error("Can't recognise image type: "+t)},_readStream:function(t){var e=i.defer(),r=[];return t.on("data",function(t){r.push(t)}),t.on("end",function(){var t=n.concat(r);e.resolve(t)}),t.on("error",function(t){e.reject(t)}),e.promise},_readPNG:function(t){var e=i.defer(),n=new o({filterType:4});return n.on("parsed",function(){e.resolve(n)}),n.on("error",function(t){e.rejecyt(t)}),t.pipe(n),e.promise},_parseOptions:function(t,e){return"number"==typeof(t=t||{})&&(t={type:t}),t.type=t.type||this._deduceFileType(e),t},read:function(t,e){var n=this;switch((e=this._parseOptions(e)).type){case s.ImageType.JPG:return this._readStream(t).then(function(t){n._data=a.decode(t)});case s.ImageType.PNG:return this._readPNG(t).then(function(t){n._data={data:t.data,width:t.width,height:t.height}});default:return i.reject(new Error("Not supported: ImageType "+e.type))}},readFile:function(t,e){var n=this;return u.fs.exists(t).then(function(i){if(i){e=n._parseOptions(e,t);var a=r.createReadStream(t);return n.read(a,e)}throw new Error("File Not Found: "+t)})},write:function(t,e){e=this._parseOptions(e);var n=i.defer();try{switch(t.on("finish",function(){n.resolve()}),t.on("error",function(t){n.reject(t)}),e.type){case s.ImageType.JPG:var r=a.encode(this._data,e.quality||90).data;t.write(r),t.end();break;case s.ImageType.PNG:var u=new o;u.width=this.width,u.height=this.height,u.data=this._data.data,u.on("end",function(){n.resolve()}),u.on("error",function(t){n.reject(t)}),u.pack().pipe(t);break;default:throw new Error("Not supported: ImageType "+e.type)}}catch(t){n.reject(t)}return n.promise},writeFile:function(t,e){e=this._parseOptions(e,t);var n=r.createWriteStream(t);return this.write(n,e)},clone:function(){return new f({width:this.width,height:this.height,data:new n(this._data.data)})},setPixel:function(t,e,n,r,i,a){if(void 0===r){var o=n;n=o.r,r=o.g,i=o.b,a=o.a}void 0===a&&(a=255);var s=4*(e*this.width+t),u=this._data.data;u[s++]=n,u[s++]=r,u[s++]=i,u[s++]=a},getPixel:function(t,e,n){var r=4*(e*this.width+t);n=n||{};var i=this._data.data;return n.r=i[r++],n.g=i[r++],n.b=i[r++],n.a=i[r++],n},negative:function(){for(var t=new f({width:this.width,height:this.height}),e=this.width*this.height,n=this._data.data,r=t._data.data,i=0,a=0,o=0;o-1&&C-1&&M=0&&M>=0?b[P]:O)+D*(g=C=0?b[P+4]:O),z=(1-D)*(m=C>=0&&M0?o:0)-(c>0?4:0)]+2*s[p-(l>0?o:0)]+1*s[p-(l>0?o:0)+(c0?4:0)]+4*s[p]+2*s[p+(c0?4:0)]+2*s[p+(l0?a[x-4]:2*a[x]-a[x+4],E=a[x],S=a[x+4],j=z0?v[x-4*h]:2*v[x]-v[x+4*h],M=v[x],I=v[x+4*h],R=N1)for(g=0;g0&&!t[o-1];)o--;a.push({children:[],index:0});var s,u=a[0];for(n=0;n0;)u=a.pop();for(u.index++,a.push(u);a.length<=n;)a.push(s={children:[],index:0}),u.children[u.index]=s.children,u=s;i++}n+10)return p>>--d&1;if(255==(p=e[n++])){var t=e[n++];if(t)throw"unexpected marker: "+(p<<8|t).toString(16)}return d=7,p>>>7}function g(t){for(var e,n=t;null!==(e=v());){if("number"==typeof(n=n[e]))return n;if("object"!=typeof n)throw"invalid huffman sequence"}return null}function m(t){for(var e=0;t>0;){var n=v();if(null===n)return;e=e<<1|n,t--}return e}function _(t){var e=m(t);return e>=1<0)y--;else for(var r=o,i=s;r<=i;){var a=g(e.huffmanTableAC),u=15&a,c=a>>4;if(0!==u)n[t[r+=c]]=_(u)*(1<>4,0===f)a<15?(y=m(a)+(1<>4;if(0!==s)n[t[a+=u]]=_(s),a++;else{if(u<15)break;a+=16}}};var I,R,L,B,F=0;for(R=1==M?i[0].blocksPerLine*i[0].blocksPerColumn:c*r.mcusPerColumn,a||(a=R);F=65488&&I<=65495))break;n+=2}return n-h}function h(t,l){var c,f,h=[],p=l.blocksPerLine,d=l.blocksPerColumn,v=p<<3,g=new Int32Array(64),m=new Uint8Array(64);function _(t,c,f){var h,p,d,v,g,m,_,y,w,b,x=l.quantizationTable,k=f;for(b=0;b<64;b++)k[b]=t[b]*x[b];for(b=0;b<8;++b){var E=8*b;0!=k[1+E]||0!=k[2+E]||0!=k[3+E]||0!=k[4+E]||0!=k[5+E]||0!=k[6+E]||0!=k[7+E]?(h=s*k[0+E]+128>>8,p=s*k[4+E]+128>>8,d=k[2+E],v=k[6+E],g=u*(k[1+E]-k[7+E])+128>>8,y=u*(k[1+E]+k[7+E])+128>>8,m=k[3+E]<<4,_=k[5+E]<<4,w=h-p+1>>1,h=h+p+1>>1,p=w,w=d*o+v*a+128>>8,d=d*a-v*o+128>>8,v=w,w=g-_+1>>1,g=g+_+1>>1,_=w,w=y+m+1>>1,m=y-m+1>>1,y=w,w=h-v+1>>1,h=h+v+1>>1,v=w,w=p-d+1>>1,p=p+d+1>>1,d=w,w=g*i+y*r+2048>>12,g=g*r-y*i+2048>>12,y=w,w=m*n+_*e+2048>>12,m=m*e-_*n+2048>>12,_=w,k[0+E]=h+y,k[7+E]=h-y,k[1+E]=p+_,k[6+E]=p-_,k[2+E]=d+m,k[5+E]=d-m,k[3+E]=v+g,k[4+E]=v-g):(w=s*k[0+E]+512>>10,k[0+E]=w,k[1+E]=w,k[2+E]=w,k[3+E]=w,k[4+E]=w,k[5+E]=w,k[6+E]=w,k[7+E]=w)}for(b=0;b<8;++b){var S=b;0!=k[8+S]||0!=k[16+S]||0!=k[24+S]||0!=k[32+S]||0!=k[40+S]||0!=k[48+S]||0!=k[56+S]?(h=s*k[0+S]+2048>>12,p=s*k[32+S]+2048>>12,d=k[16+S],v=k[48+S],g=u*(k[8+S]-k[56+S])+2048>>12,y=u*(k[8+S]+k[56+S])+2048>>12,m=k[24+S],_=k[40+S],w=h-p+1>>1,h=h+p+1>>1,p=w,w=d*o+v*a+2048>>12,d=d*a-v*o+2048>>12,v=w,w=g-_+1>>1,g=g+_+1>>1,_=w,w=y+m+1>>1,m=y-m+1>>1,y=w,w=h-v+1>>1,h=h+v+1>>1,v=w,w=p-d+1>>1,p=p+d+1>>1,d=w,w=g*i+y*r+2048>>12,g=g*r-y*i+2048>>12,y=w,w=m*n+_*e+2048>>12,m=m*e-_*n+2048>>12,_=w,k[0+S]=h+y,k[56+S]=h-y,k[8+S]=p+_,k[48+S]=p-_,k[16+S]=d+m,k[40+S]=d-m,k[24+S]=v+g,k[32+S]=v-g):(w=s*f[b+0]+8192>>14,k[0+S]=w,k[8+S]=w,k[16+S]=w,k[24+S]=w,k[32+S]=w,k[40+S]=w,k[48+S]=w,k[56+S]=w)}for(b=0;b<64;++b){var j=128+(k[b]+8>>4);c[b]=j<0?0:j>255?255:j}}for(var y=0;y255?255:t}return l.prototype={load:function(t){var e=new XMLHttpRequest;e.open("GET",t,!0),e.responseType="arraybuffer",e.onload=function(){var t=new Uint8Array(e.response||e.mozResponseArrayBuffer);this.parse(t),this.onload&&this.onload()}.bind(this),e.send(null)},parse:function(e){var n=0;e.length;function r(){var t=e[n]<<8|e[n+1];return n+=2,t}function i(){var t=r(),i=e.subarray(n,n+t-2);return n+=i.length,i}function a(t){var e,n,r=0,i=0;for(n in t.components)t.components.hasOwnProperty(n)&&(r<(e=t.components[n]).h&&(r=e.h),i>4==0)for(z=0;z<64;z++){b[t[z]]=e[n++]}else{if(w>>4!=1)throw"DQT: invalid table spec";for(z=0;z<64;z++){b[t[z]]=r()}}p[15&w]=b}break;case 65472:case 65473:case 65474:r(),(o={}).extended=65473===m,o.progressive=65474===m,o.precision=e[n++],o.scanLines=r(),o.samplesPerLine=r(),o.components={},o.componentsOrder=[];var x,k=e[n++];for(N=0;N>4,S=15&e[n+1],j=e[n+2];o.componentsOrder.push(x),o.components[x]={h:E,v:S,quantizationIdx:j},n+=3}a(o),d.push(o);break;case 65476:var T=r();for(N=2;N>4==0?g:v)[15&A]=c(C,I)}break;case 65501:r(),s=r();break;case 65498:r();var R=e[n++],L=[];for(N=0;N>4],q.huffmanTableAC=v[15&B],L.push(q)}var F=e[n++],P=e[n++],O=e[n++],D=f(e,n,o,L,s,F,P,O>>4,15&O);n+=D;break;default:if(255==e[n-3]&&e[n-2]>=192&&e[n-2]<=254){n-=3;break}throw"unknown JPEG marker "+m.toString(16)}m=r()}if(1!=d.length)throw"only single frame JPEGs supported";for(var N=0;N=0;)e&1<>8&255),F(255&t)}function O(t,e,n,r,i){var a,o=i[0],s=i[240];for(var u=function(t,e){var n,r,i,a,o,s,u,l,c,f,h=0;for(c=0;c<8;++c){n=t[h],r=t[h+1],i=t[h+2],a=t[h+3],o=t[h+4],s=t[h+5],u=t[h+6];var p=n+(l=t[h+7]),v=n-l,g=r+u,m=r-u,_=i+s,y=i-s,w=a+o,b=a-o,x=p+w,k=p-w,E=g+_,S=g-_;t[h]=x+E,t[h+4]=x-E;var j=.707106781*(S+k);t[h+2]=k+j,t[h+6]=k-j;var T=.382683433*((x=b+y)-(S=m+v)),A=.5411961*x+T,C=1.306562965*S+T,M=.707106781*(E=y+m),I=v+M,R=v-M;t[h+5]=R+A,t[h+3]=R-A,t[h+1]=I+C,t[h+7]=I-C,h+=8}for(h=0,c=0;c<8;++c){n=t[h],r=t[h+8],i=t[h+16],a=t[h+24],o=t[h+32],s=t[h+40],u=t[h+48];var L=n+(l=t[h+56]),B=n-l,F=r+u,P=r-u,O=i+s,D=i-s,N=a+o,U=a-o,z=L+N,q=L-N,V=F+O,G=F-O;t[h]=z+V,t[h+32]=z-V;var H=.707106781*(G+q);t[h+16]=q+H,t[h+48]=q-H;var W=.382683433*((z=U+D)-(G=P+B)),Z=.5411961*z+W,Y=1.306562965*G+W,X=.707106781*(V=D+P),$=B+X,J=B-X;t[h+40]=J+Z,t[h+24]=J-Z,t[h+8]=$+Y,t[h+56]=$-Y,h++}for(c=0;c<64;++c)f=t[c]*e[c],d[c]=f>0?f+.5|0:f-.5|0;return d}(t,e),l=0;l<64;++l)v[E[l]]=u[l];var c=v[0]-n;n=v[0],0==c?B(r[0]):(B(r[p[a=32767+c]]),B(h[a]));for(var f=63;f>0&&0==v[f];f--);if(0==f)return B(o),n;for(var g,m=1;m<=f;){for(var _=m;0==v[m]&&m<=f;++m);var y=m-_;if(y>=16){g=y>>4;for(var w=1;w<=g;++w)B(s);y&=15}a=32767+v[m],B(i[(y<<4)+p[a]]),B(h[a]),m++}return 63!=f&&B(o),n}function D(t){if(t<=0&&(t=1),t>100&&(t=100),o!=t){(function(t){for(var e=[16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99],n=0;n<64;n++){var r=s((e[n]*t+50)/100);r<1?r=1:r>255&&(r=255),u[E[n]]=r}for(var i=[17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99],a=0;a<64;a++){var o=s((i[a]*t+50)/100);o<1?o=1:o>255&&(o=255),l[E[a]]=o}for(var h=[1,1.387039845,1.306562965,1.175875602,1,.785694958,.5411961,.275899379],p=0,d=0;d<8;d++)for(var v=0;v<8;v++)c[p]=1/(u[E[p]]*h[d]*h[v]*8),f[p]=1/(l[E[p]]*h[d]*h[v]*8),p++})(t<50?Math.floor(5e3/t):Math.floor(200-2*t)),o=t}}this.encode=function(e,o){(new Date).getTime();o&&D(o),g=new Array,m=0,_=7,P(65496),P(65504),P(16),F(74),F(70),F(73),F(70),F(0),F(1),F(1),F(0),P(1),P(1),F(0),F(0),function(){P(65499),P(132),F(0);for(var t=0;t<64;t++)F(u[t]);F(1);for(var e=0;e<64;e++)F(l[e])}(),function(t,e){P(65472),P(17),F(8),P(e),P(t),F(3),F(1),F(17),F(0),F(2),F(17),F(1),F(3),F(17),F(1)}(e.width,e.height),function(){P(65476),P(418),F(0);for(var t=0;t<16;t++)F(S[t+1]);for(var e=0;e<=11;e++)F(j[e]);F(16);for(var n=0;n<16;n++)F(T[n+1]);for(var r=0;r<=161;r++)F(A[r]);F(1);for(var i=0;i<16;i++)F(C[i+1]);for(var a=0;a<=11;a++)F(M[a]);F(17);for(var o=0;o<16;o++)F(I[o+1]);for(var s=0;s<=161;s++)F(R[s])}(),P(65498),P(12),F(3),F(1),F(0),F(2),F(17),F(3),F(17),F(0),F(63),F(0);var s=0,h=0,p=0;m=0,_=7,this.encode.displayName="_encode_";for(var d,v,x,E,L,N,U,z,q,V=e.data,G=e.width,H=e.height,W=4*G,Z=0;Z>3)*W+(U=4*(7&q)),Z+z>=H&&(N-=W*(Z+1+z-H)),d+U>=W&&(N-=d+U-W+4),v=V[N++],x=V[N++],E=V[N++],y[q]=(k[v]+k[x+256>>0]+k[E+512>>0]>>16)-128,w[q]=(k[v+768>>0]+k[x+1024>>0]+k[E+1280>>0]>>16)-128,b[q]=(k[v+1280>>0]+k[x+1536>>0]+k[E+1792>>0]>>16)-128;s=O(y,c,s,n,i),h=O(w,f,h,r,a),p=O(b,f,p,r,a),d+=32}Z+=8}if(_>=0){var Y=[];Y[1]=_+1,Y[0]=(1<<_+1)-1,B(Y)}return P(65497),new t(g)},function(){(new Date).getTime();e||(e=50),function(){for(var t=String.fromCharCode,e=0;e<256;e++)x[e]=t(e)}(),n=L(S,j),r=L(C,M),i=L(T,A),a=L(I,R),function(){for(var t=1,e=2,n=1;n<=15;n++){for(var r=t;r>0]=38470*t,k[t+512>>0]=7471*t+32768,k[t+768>>0]=-11059*t,k[t+1024>>0]=-21709*t,k[t+1280>>0]=32768*t+8421375,k[t+1536>>0]=-27439*t,k[t+1792>>0]=-5329*t}(),D(e),(new Date).getTime()}()}e.exports=function(t,e){void 0===e&&(e=50);return{data:new n(e).encode(t,e),width:t.width,height:t.height}}}).call(this,t("buffer").Buffer)},{buffer:5}],70:[function(t,e,n){arguments[4][42][0].apply(n,arguments)},{dup:42}],71:[function(t,e,n){"use strict";e.exports=function(t){for(var e=new Array(t),n=0;n>i;0!=(e&o)&&p++;var d=n>>i;return 0!=(n&o)&&d++,function(t,e,n,o,s,u){function l(t,e,n){return tn?n:t}var c=r.BitMatrix.createEmpty(o,s);function f(t,e,n,r,i){for(var o=n*i+e,s=0;sd&&(p=d);for(var v=0;vm&&(g=m);for(var _=l(v,2,e-3),y=l(h,2,n-3),w=0,b=-2;b<=2;b++){var x=u[y+b];w+=x[_-2],w+=x[_-1],w+=x[_],w+=x[_+1],w+=x[_+2]}f(t,g,p,w/25,o)}}return c}(u,p,d,e,n,function(t,e,n,r,o){for(var u=new Array(n),l=0;lh&&(f=h);for(var p=0;pv&&(d=v);for(var g=0,m=255,_=0,y=0,w=f*r+d;y_&&(_=x)}if(_-m>s)for(y++,w+=r;y>2*i;if(_-m<=s&&(k=m>>1,c>0&&p>0)){var E=u[c-1][p]+2*u[c][p-1]+u[c-1][p-1]>>2;m=n&&(t++,r+=e.estimatedModuleSize)}),t<3)return!1;for(var a=r/i,o=0,s=0;s=0&&c(n,l);)o[2]++,l--;if(l<0)return null;for(;l>=0&&!c(n,l)&&o[1]<=r;)o[1]++,l--;if(l<0||o[1]>r)return null;for(;l>=0&&c(n,l)&&o[0]<=r;)o[0]++,l--;if(o[0]>r)return null;for(l=e+1;l=r)return null;for(;l=r)return null;var f=o[0]+o[1]+o[2]+o[3]+o[4];return 5*Math.abs(f-i)>=2*i?null:s(o)?u(o,l):null}(r,Math.floor(f),n[2],l);if(null!=h&&null!=(f=function(e,n,r,i){for(var a=t.width,o=[0,0,0,0,0],l=e;l>=0&&c(l,n);)o[2]++,l--;if(l<0)return null;for(;l>=0&&!c(l,n)&&o[1]<=r;)o[1]++,l--;if(l<0||o[1]>r)return null;for(;l>=0&&c(l,n)&&o[0]<=r;)o[0]++,l--;if(o[0]>r)return null;for(l=e+1;l=r)return null;for(;l=r)return null;var f=o[0]+o[1]+o[2]+o[3]+o[4];return 5*Math.abs(f-i)>=i?null:s(o)?u(o,l):null}(Math.floor(f),Math.floor(h),n[2],l))&&(!a||function(e,n,r,i){for(var a=t.height,o=t.width,u=[0,0,0,0,0],l=0;e-l>=0&&c(n-l,e-l);)u[2]++,l++;if(e-l<0||n-l<0)return!1;for(;e-l>=0&&n-l>=0&&!c(n-l,e-l)&&u[1]<=r;)u[1]++,l++;if(e-l<0||n-l<0||u[1]>r)return!1;for(;e-l>=0&&n-l>=0&&c(n-l,e-l)&&u[0]<=r;)u[0]++,l++;if(u[0]>r)return!1;for(l=1;e+l=a||n+l>=o)return!1;for(;e+l=a||n+l>=o||u[3]>=r)return!1;for(;e+l=r)return!1;var f=u[0]+u[1]+u[2]+u[3]+u[4];return Math.abs(f-i)<2*i&&s(u)}(Math.floor(h),Math.floor(f),n[2],l))){for(var p=l/7,d=!1,v=0;v=n){if(null!=t)return a=!0,Math.floor(Math.abs(t.x-e.x)-Math.abs(t.y-e.y))/2;t=e}}),0}var d=t.height,v=t.width,g=Math.floor(3*d/(4*i));g_[2]&&(y+=x-_[2]-g,b=v-1)}_=[0,0,0,0,0],w=0}else _=[_[2],_[3],_[4],1,0],w=3;else _[++w]++;else _[w]++;s(_)&&h(_,y,v,!1)&&(g=_[0],a&&(m=f()))}var k=function(){var t=e.length;if(t<3)return null;if(t>3){var n=0,r=0;e.forEach(function(t){var e=t.estimatedModuleSize;n+=e,r+=e*e});var i=n/t,a=Math.sqrt(r/t-i*i);e.sort(function(t,e){var n=Math.abs(e.estimatedModuleSize-i),r=Math.abs(t.estimatedModuleSize-i);return n3;s++){var u=e[s];Math.abs(u.estimatedModuleSize-i)>o&&(e.splice(s,1),s--)}}return e.length>3&&(n=0,e.forEach(function(t){n+=t.estimatedModuleSize}),i=n/e.length,e.sort(function(t,e){if(e.count===t.count){var n=Math.abs(e.estimatedModuleSize-i),r=Math.abs(t.estimatedModuleSize-i);return n=i&&a>=o?(n=t[0],e=t[1],r=t[2]):o>=a&&o>=i?(n=t[1],e=t[0],r=t[2]):(n=t[2],e=t[0],r=t[1]),function(t,e,n){var r=e.x,i=e.y;return(n.x-r)*(t.y-i)-(n.y-i)*(t.x-r)}(e,n,r)<0){var s=e;e=r,r=s}return{bottomLeft:{x:e.x,y:e.y},topLeft:{x:n.x,y:n.y},topRight:{x:r.x,y:r.y}}}(k):null}},function(t,e,n){"use strict";var r=n(5),i=n(7),a=n(8),o=n(2),s=n(6);function u(t,e,n){for(var r=!0,i=0;it||o<-1||o>e)throw new Error;r=!1,-1==a?(n[i]=0,r=!0):a==t&&(n[i]=t-1,r=!0),-1==o?(n[i+1]=0,r=!0):o==e&&(n[i+1]=e-1,r=!0)}r=!0;for(i=n.length-2;i>=0&&r;i-=2){a=Math.floor(n[i]),o=Math.floor(n[i+1]);if(a<-1||a>t||o<-1||o>e)throw new Error;r=!1,-1==a?(n[i]=0,r=!0):a==t&&(n[i]=t-1,r=!0),-1==o?(n[i+1]=0,r=!0):o==e&&(n[i+1]=e-1,r=!0)}return n}function l(t,e,n,r){return Math.sqrt((n-t)*(n-t)+(r-e)*(r-e))}function c(t,e,n,i,a){e=Math.floor(e),n=Math.floor(n);var o=Math.floor(i*t),s=Math.max(0,e-o),u=Math.min(a.width,e+o);if(u-s<3*t)return null;var l=Math.max(0,n-o),c=Math.min(a.height-1,n+o);return r.findAlignment(s,l,u-s,c-l,t,a)}function f(t,e,n,r,i){t=Math.floor(t),e=Math.floor(e),n=Math.floor(n),r=Math.floor(r);var a=Math.abs(r-e)>Math.abs(n-t);if(a){var o=t;t=e,e=o,o=n,n=r,r=o}for(var s=Math.abs(n-t),u=Math.abs(r-e),c=-s>>1,f=t0){if(g==r)break;g+=h,c-=s}}return 2==p?l(n+f,r,t,e):NaN}function h(t,e,n,r,i){var a=f(t,e,n,r,i),o=1,s=t-(n-t);s<0?(o=t/(t-s),s=0):s>=i.width&&(o=(i.width-1-t)/(s-t),s=i.width-1);var u=e-(r-e)*o;return o=1,u<0?(o=e/(e-u),u=0):u>=i.height&&(o=(i.height-1-e)/(u-e),u=i.height-1),(a+=f(t,e,s=t+(s-t)*o,u,i))-1}function p(t,e,n){var r=h(t.x,t.y,e.x,e.y,n),i=h(e.x,e.y,t.x,t.y,n);return s.isNaN(r)?i/7:s.isNaN(i)?r/7:(r+i)/14}e.extract=function(t,e){var n=function(t,e,n,r){return(p(t,e,r)+p(t,n,r))/2}(e.topLeft,e.topRight,e.bottomLeft,t);if(n<1)return null;var r=function(t,e,n,r){var i=7+(Math.round(l(t.x,t.y,e.x,e.y)/r)+Math.round(l(t.x,t.y,n.x,n.y)/r)>>1);switch(3&i){case 0:i++;break;case 2:i--}return i}(e.topLeft,e.topRight,e.bottomLeft,n);if(!r)return null;var s=function(t){if(t%4!=1)return null;var e=t-17>>2;return e<1||e>40?null:a.getVersionForNumber(e)}(r);if(null==s)return null;var f=s.getDimensionForVersion()-7,h=null;if(s.alignmentPatternCenters.length>0)for(var d=e.topRight.x-e.topLeft.x+e.bottomLeft.x,v=e.topRight.y-e.topLeft.y+e.bottomLeft.y,g=1-3/f,m=e.topLeft.x+g*(d-e.topLeft.x),_=e.topLeft.y+g*(v-e.topLeft.y),y=4;y<=16&&!(h=c(n,m,_,y,t));y<<=1);return function(t,e,n){if(e<=0)return null;for(var r=o.BitMatrix.createEmpty(e,e),a=new Array(e<<1),s=0;s>1),a[f+1]=c;a=i.transformPoints(n,a);try{var h=u(t.width,t.height,a)}catch(t){return null}for(f=0;f>1,s,t.get(Math.floor(h[f]),Math.floor(h[f+1])))}return r}(t,r,function(t,e,n,r,a){var o,s,u,l,c=a-3.5;return null!=r?(o=r.x,s=r.y,u=l=c-3):(o=e.x-t.x+n.x,s=e.y-t.y+n.y,u=l=c),i.quadrilateralToQuadrilateral(3.5,3.5,c,3.5,u,l,3.5,c,t.x,t.y,e.x,e.y,o,s,n.x,n.y)}(e.topLeft,e.topRight,e.bottomLeft,h,r))}},function(t,e,n){"use strict";var r=n(6);function i(t,e,n,r){if(Math.abs(n-t.y)<=e&&Math.abs(r-t.x)<=e){var i=Math.abs(e-t.estimatedModuleSize);return i<=1||i<=t.estimatedModuleSize}return!1}function a(t,e,n,r){return{x:(t.x+n)/2,y:(t.y+e)/2,estimatedModuleSize:(t.estimatedModuleSize+r)/2}}function o(t,e){for(var n=e/2,r=0;r<3;r++)if(Math.abs(e-t[r])>=n)return!1;return!0}function s(t,e){var n=e-t[2]-t[1]/2;return r.isNaN(n)?null:n}e.findAlignment=function(t,e,n,r,u,l){var c=[];function f(t,e,n,r){var u=t[0]+t[1]+t[2],f=s(t,n);if(null==f)return null;var h=function(t,e,n,r,i,a){for(var u=a.height,l=[0,0,0],c=t;c>=0&&a.get(e,c)&&l[1]<=n;)l[1]++,c--;if(c<0||l[1]>n)return null;for(;c>=0&&!a.get(e,c)&&l[0]<=n;)l[0]++,c--;if(l[0]>n)return null;for(c=t+1;cn)return null;for(;cn)return null;var f=l[0]+l[1]+l[2];return 5*Math.abs(f-r)>=2*r?null:o(l,i)?s(l,c):null}(e,Math.floor(f),2*t[1],u,r,l);if(null!=h){var p=(t[0]+t[1]+t[2])/3;for(var d in c){var v=c[d];if(i(v,p,h,f))return a(v,h,f,p)}var g={x:f,y:h,estimatedModuleSize:p};c.push(g)}return null}for(var h=t+n,p=e+(r>>1),d=[0,0,0],v=0;v>1:-(v+1>>1));d[0]=0,d[1]=0,d[2]=0;for(var m=t;m>4&15]+n[t>>8&15]+n[t>>12&15]+n[t>>16&15]+n[t>>20&15]+n[t>>24&15]+n[t>>28&15]},e.isNaN=function(t){return"[object Number]"===Object.prototype.toString.call(t)&&t!==+t}},function(t,e){"use strict";function n(t,e,n,r,i,a,o,s){var u=t-n+i-o,l=e-r+a-s;if(0==u&&0==l)return{a11:n-t,a21:i-n,a31:t,a12:r-e,a22:a-r,a32:e,a13:0,a23:0,a33:1};var c=n-i,f=o-i,h=r-a,p=s-a,d=c*p-f*h,v=(u*p-f*l)/d,g=(c*l-u*h)/d;return{a11:n-t+v*n,a21:o-t+g*o,a31:t,a12:r-e+v*r,a22:s-e+g*s,a32:e,a13:v,a23:g,a33:1}}e.transformPoints=function(t,e){for(var n=e.length,r=t.a11,i=t.a12,a=t.a13,o=t.a21,s=t.a22,u=t.a23,l=t.a31,c=t.a32,f=t.a33,h=0;h40)throw new Error("Invalid version number "+t);return u[t-1]}e.getVersionForNumber=l},function(t,e,n){"use strict";var r=n(2),i=n(10),a=n(6),o=n(12),s=n(8),u=21522,l=[[21522,0],[20773,1],[24188,2],[23371,3],[17913,4],[16590,5],[20375,6],[19104,7],[30660,8],[29427,9],[32170,10],[30877,11],[26159,12],[25368,13],[27713,14],[26998,15],[5769,16],[5054,17],[7399,18],[6608,19],[1890,20],[597,21],[3340,22],[2107,23],[13663,24],[12392,25],[16177,26],[14854,27],[9396,28],[8579,29],[11994,30],[11245,31]],c=[function(t,e){return 0==(t+e&1)},function(t,e){return 0==(1&t)},function(t,e){return e%3==0},function(t,e){return(t+e)%3==0},function(t,e){return 0==((t>>1)+e/3&1)},function(t,e){return(t*e&1)+t*e%3==0},function(t,e){return 0==((t*e&1)+t*e%3&1)},function(t,e){return 0==((t+e&1)+t*e%3&1)}],f=[{ordinal:1,bits:0,name:"M"},{ordinal:0,bits:1,name:"L"},{ordinal:3,bits:2,name:"H"},{ordinal:2,bits:3,name:"Q"}];function h(t,e,n){for(var i=c[n.dataMask],a=t.height,o=function(t){for(var e=t.getDimensionForVersion(),n=new Array(e*e),i=0;i6&&(a.setRegion(e-11,0,3,6),a.setRegion(0,e-11,6,3)),a}(e),s=!0,u=[],l=0,f=0,h=0,p=a-1;p>0;p-=2){6==p&&p--;for(var d=0;d>3&3],dataMask:7&t}}function d(t,e){for(var n=1/0,r=0,i=0;i=0;r--)e=t.copyBit(8,r,e);var i=t.height,a=0,o=i-7;for(r=i-1;r>=o;r--)a=t.copyBit(8,r,a);for(n=i-8;n>2;if(n<=6)return s.getVersionForNumber(n);for(var r=0,i=e-11,a=5;a>=0;a--)for(var o=e-9;o>=i;o--)r=t.copyBit(o,a,r);var u=s.Version.decodeVersionInformation(r);if(null!=u&&u.getDimensionForVersion()==e)return u;for(r=0,o=5;o>=0;o--)for(a=e-9;a>=i;a--)r=t.copyBit(o,a,r);return null!=(u=s.Version.decodeVersionInformation(r))&&u.getDimensionForVersion()==e?u:null}(t);if(!e)return null;var n=v(t);if(!n)return null;var r=n.errorCorrectionLevel,a=h(t,e,n);if(!a)return null;var o=function(t,e,n){if(t.length!=e.totalCodewords)throw new Error("Invalid number of codewords for version; got "+t.length+" expected "+e.totalCodewords);var r=e.getECBlocksForLevel(n),i=0,a=r.ecBlocks;a.forEach(function(t){i+=t.count});var o=new Array(i),s=0;a.forEach(function(t){for(var e=0;e=0&&o[l].codewords.length!=u;)l--;l++;for(var c=u-r.ecCodewordsPerBlock,f=0,h=0;h=e.length)throw new Error("Could not decode alphanumeric char");return e[t].charCodeAt(0)}var a=function(){function t(t,e){this.characterCountBitsForVersions=t,this.bits=e}return t.prototype.getCharacterCountBits=function(t){if(null==this.characterCountBitsForVersions)throw new Error("Character count doesn't apply to this mode");var e;return e=t<=9?0:t<=26?1:2,this.characterCountBitsForVersions[e]},t}(),o=new a([0,0,0],0),s=new a([10,12,14],1),u=new a([9,11,13],2),l=new a([0,0,0],3),c=new a([8,16,16],4),f=new a(null,7),h=new a([8,10,12],8),p=new a(null,5),d=new a(null,9),v=new a([8,10,12],13);function g(t){switch(t){case 0:return o;case 1:return s;case 2:return u;case 3:return l;case 4:return c;case 5:return p;case 7:return f;case 8:return h;case 9:return d;case 13:return v;default:throw new Error("Couldn't decode mode from byte array")}}function m(t){var e=t.readBits(8);if(0==(128&e))return 127&e;if(128==(192&e))return(63&e)<<8|t.readBits(8);if(192==(224&e))return(31&e)<<16|t.readBits(16);throw new Error("Bad ECI bits starting with byte "+e)}function _(t,e,n){if(13*n>t.available())return!1;for(var r=new Array(2*n),i=0;n>0;){var a=t.readBits(13),o=Math.floor(a/96)<<8|a%96;o+=o<959?41377:42657,r[i]=o>>8&255,r[i+1]=255&o,i+=2,n--}return e.val=r,!0}function y(t,e,n){for(;n>=3;){if(t.available()<10)return!1;var r=t.readBits(10);if(r>=1e3)return!1;e.val.push(i(Math.floor(r/100))),e.val.push(i(Math.floor(r/10)%10)),e.val.push(i(r%10)),n-=3}if(2==n){if(t.available()<7)return!1;var a=t.readBits(7);if(a>=100)return!1;e.val.push(i(Math.floor(a/10))),e.val.push(i(a%10))}else if(1==n){if(t.available()<4)return!1;var o=t.readBits(4);if(o>=10)return!1;e.val.push(i(o))}return!0}function w(t,e,n,r){for(var a=e.val.length;n>1;){if(t.available()<11)return!1;var o=t.readBits(11);e.val.push(i(Math.floor(o/45))),e.val.push(i(o%45)),n-=2}if(1==n){if(t.available()<6)return!1;e.val.push(i(t.readBits(6)))}if(r)for(var s=a;st.available())return!1;for(var r=new Array(n),i=0;i30)return null}else if(i==v){var j=a.readBits(4),T=a.readBits(i.getCharacterCountBits(e));if(j==x&&!_(a,k,T))return null}else{var A=a.readBits(i.getCharacterCountBits(e));if(i==s){if(!y(a,k,A))return null}else if(i==u){if(!w(a,k,A,E))return null}else if(i==c){if(!b(a,k,A))return null}else if(i!=h)return null}return k.val}},function(t,e){"use strict";var n=function(){function t(t){this.byteOffset=0,this.bitOffset=0,this.bytes=t}return t.prototype.readBits=function(t){if(t<1||t>32||t>this.available())throw new Error("Cannot read "+t.toString()+" bits");var e=0;if(this.bitOffset>0){var n=8-this.bitOffset,r=t>8-r<<(a=n-r);e=(this.bytes[this.byteOffset]&i)>>a,t-=r,this.bitOffset+=r,8==this.bitOffset&&(this.bitOffset=0,this.byteOffset++)}if(t>0){for(;t>=8;)e=e<<8|255&this.bytes[this.byteOffset],this.byteOffset++,t-=8;if(t>0){var a;i=255>>(a=8-t)<>a,this.bitOffset+=t}}return e},t.prototype.available=function(){return 8*(this.bytes.length-this.byteOffset)-this.bitOffset},t}();e.BitStream=n},function(t,e){"use strict";var n=function(){function t(){this.field=new i(285,256,0)}return t.prototype.decode=function(t,e){for(var n=new r(this.field,t),a=new Array(e),o=!0,s=0;s=n/2;){var u=i,l=o;if(o=s,(i=a).isZero())return null;a=u;for(var c=this.field.zero,f=i.getCoefficient(i.degree()),h=this.field.inverse(f);a.degree()>=i.degree()&&!a.isZero();){var p=a.degree()-i.degree(),d=this.field.multiply(a.getCoefficient(a.degree()),h);c=c.addOrSubtract(this.field.buildMonomial(p,d)),a=a.addOrSubtract(i.multiplyByMonomial(p,d))}if(s=c.multiplyPoly(o).addOrSubtract(l),a.degree()>=i.degree())return null}var v=s.getCoefficient(0);if(0==v)return null;var g=this.field.inverse(v);return[s.multiply(g),a.multiply(g)]},t.prototype.findErrorLocations=function(t){var e=t.degree();if(1==e)return[t.getCoefficient(1)];for(var n=new Array(e),r=0,i=1;i1&&0==e[0]){for(var r=1;rr.length){var a=n;n=r,r=a}for(var o=new Array(r.length),s=r.length-n.length,u=0;u=this.size&&(t^=this.primitive,t&=this.size-1);for(e=0;e>>1,D=[["ary",x],["bind",v],["bindKey",g],["curry",_],["curryRight",y],["flip",E],["partial",w],["partialRight",b],["rearg",k]],N="[object Arguments]",U="[object Array]",z="[object AsyncFunction]",q="[object Boolean]",V="[object Date]",G="[object DOMException]",H="[object Error]",W="[object Function]",Z="[object GeneratorFunction]",Y="[object Map]",X="[object Number]",$="[object Null]",J="[object Object]",Q="[object Proxy]",K="[object RegExp]",tt="[object Set]",et="[object String]",nt="[object Symbol]",rt="[object Undefined]",it="[object WeakMap]",at="[object WeakSet]",ot="[object ArrayBuffer]",st="[object DataView]",ut="[object Float32Array]",lt="[object Float64Array]",ct="[object Int8Array]",ft="[object Int16Array]",ht="[object Int32Array]",pt="[object Uint8Array]",dt="[object Uint8ClampedArray]",vt="[object Uint16Array]",gt="[object Uint32Array]",mt=/\b__p \+= '';/g,_t=/\b(__p \+=) '' \+/g,yt=/(__e\(.*?\)|\b__t\)) \+\n'';/g,wt=/&(?:amp|lt|gt|quot|#39);/g,bt=/[&<>"']/g,xt=RegExp(wt.source),kt=RegExp(bt.source),Et=/<%-([\s\S]+?)%>/g,St=/<%([\s\S]+?)%>/g,jt=/<%=([\s\S]+?)%>/g,Tt=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,At=/^\w*$/,Ct=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,Mt=/[\\^$.*+?()[\]{}|]/g,It=RegExp(Mt.source),Rt=/^\s+|\s+$/g,Lt=/^\s+/,Bt=/\s+$/,Ft=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Pt=/\{\n\/\* \[wrapped with (.+)\] \*/,Ot=/,? & /,Dt=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Nt=/\\(\\)?/g,Ut=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,zt=/\w*$/,qt=/^[-+]0x[0-9a-f]+$/i,Vt=/^0b[01]+$/i,Gt=/^\[object .+?Constructor\]$/,Ht=/^0o[0-7]+$/i,Wt=/^(?:0|[1-9]\d*)$/,Zt=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,Yt=/($^)/,Xt=/['\n\r\u2028\u2029\\]/g,$t="\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff",Jt="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",Qt="[\\ud800-\\udfff]",Kt="["+Jt+"]",te="["+$t+"]",ee="\\d+",ne="[\\u2700-\\u27bf]",re="[a-z\\xdf-\\xf6\\xf8-\\xff]",ie="[^\\ud800-\\udfff"+Jt+ee+"\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde]",ae="\\ud83c[\\udffb-\\udfff]",oe="[^\\ud800-\\udfff]",se="(?:\\ud83c[\\udde6-\\uddff]){2}",ue="[\\ud800-\\udbff][\\udc00-\\udfff]",le="[A-Z\\xc0-\\xd6\\xd8-\\xde]",ce="(?:"+re+"|"+ie+")",fe="(?:"+le+"|"+ie+")",he="(?:"+te+"|"+ae+")"+"?",pe="[\\ufe0e\\ufe0f]?"+he+("(?:\\u200d(?:"+[oe,se,ue].join("|")+")[\\ufe0e\\ufe0f]?"+he+")*"),de="(?:"+[ne,se,ue].join("|")+")"+pe,ve="(?:"+[oe+te+"?",te,se,ue,Qt].join("|")+")",ge=RegExp("['’]","g"),me=RegExp(te,"g"),_e=RegExp(ae+"(?="+ae+")|"+ve+pe,"g"),ye=RegExp([le+"?"+re+"+(?:['’](?:d|ll|m|re|s|t|ve))?(?="+[Kt,le,"$"].join("|")+")",fe+"+(?:['’](?:D|LL|M|RE|S|T|VE))?(?="+[Kt,le+ce,"$"].join("|")+")",le+"?"+ce+"+(?:['’](?:d|ll|m|re|s|t|ve))?",le+"+(?:['’](?:D|LL|M|RE|S|T|VE))?","\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",ee,de].join("|"),"g"),we=RegExp("[\\u200d\\ud800-\\udfff"+$t+"\\ufe0e\\ufe0f]"),be=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,xe=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],ke=-1,Ee={};Ee[ut]=Ee[lt]=Ee[ct]=Ee[ft]=Ee[ht]=Ee[pt]=Ee[dt]=Ee[vt]=Ee[gt]=!0,Ee[N]=Ee[U]=Ee[ot]=Ee[q]=Ee[st]=Ee[V]=Ee[H]=Ee[W]=Ee[Y]=Ee[X]=Ee[J]=Ee[K]=Ee[tt]=Ee[et]=Ee[it]=!1;var Se={};Se[N]=Se[U]=Se[ot]=Se[st]=Se[q]=Se[V]=Se[ut]=Se[lt]=Se[ct]=Se[ft]=Se[ht]=Se[Y]=Se[X]=Se[J]=Se[K]=Se[tt]=Se[et]=Se[nt]=Se[pt]=Se[dt]=Se[vt]=Se[gt]=!0,Se[H]=Se[W]=Se[it]=!1;var je={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Te=parseFloat,Ae=parseInt,Ce="object"==typeof t&&t&&t.Object===Object&&t,Me="object"==typeof self&&self&&self.Object===Object&&self,Ie=Ce||Me||Function("return this")(),Re="object"==typeof n&&n&&!n.nodeType&&n,Le=Re&&"object"==typeof e&&e&&!e.nodeType&&e,Be=Le&&Le.exports===Re,Fe=Be&&Ce.process,Pe=function(){try{var t=Le&&Le.require&&Le.require("util").types;return t||Fe&&Fe.binding&&Fe.binding("util")}catch(t){}}(),Oe=Pe&&Pe.isArrayBuffer,De=Pe&&Pe.isDate,Ne=Pe&&Pe.isMap,Ue=Pe&&Pe.isRegExp,ze=Pe&&Pe.isSet,qe=Pe&&Pe.isTypedArray;function Ve(t,e,n){switch(n.length){case 0:return t.call(e);case 1:return t.call(e,n[0]);case 2:return t.call(e,n[0],n[1]);case 3:return t.call(e,n[0],n[1],n[2])}return t.apply(e,n)}function Ge(t,e,n,r){for(var i=-1,a=null==t?0:t.length;++i-1}function $e(t,e,n){for(var r=-1,i=null==t?0:t.length;++r-1;);return n}function yn(t,e){for(var n=t.length;n--&&on(e,t[n],0)>-1;);return n}var wn=fn({"À":"A","Á":"A","Â":"A","Ã":"A","Ä":"A","Å":"A","à":"a","á":"a","â":"a","ã":"a","ä":"a","å":"a","Ç":"C","ç":"c","Ð":"D","ð":"d","È":"E","É":"E","Ê":"E","Ë":"E","è":"e","é":"e","ê":"e","ë":"e","Ì":"I","Í":"I","Î":"I","Ï":"I","ì":"i","í":"i","î":"i","ï":"i","Ñ":"N","ñ":"n","Ò":"O","Ó":"O","Ô":"O","Õ":"O","Ö":"O","Ø":"O","ò":"o","ó":"o","ô":"o","õ":"o","ö":"o","ø":"o","Ù":"U","Ú":"U","Û":"U","Ü":"U","ù":"u","ú":"u","û":"u","ü":"u","Ý":"Y","ý":"y","ÿ":"y","Æ":"Ae","æ":"ae","Þ":"Th","þ":"th","ß":"ss","Ā":"A","Ă":"A","Ą":"A","ā":"a","ă":"a","ą":"a","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","ć":"c","ĉ":"c","ċ":"c","č":"c","Ď":"D","Đ":"D","ď":"d","đ":"d","Ē":"E","Ĕ":"E","Ė":"E","Ę":"E","Ě":"E","ē":"e","ĕ":"e","ė":"e","ę":"e","ě":"e","Ĝ":"G","Ğ":"G","Ġ":"G","Ģ":"G","ĝ":"g","ğ":"g","ġ":"g","ģ":"g","Ĥ":"H","Ħ":"H","ĥ":"h","ħ":"h","Ĩ":"I","Ī":"I","Ĭ":"I","Į":"I","İ":"I","ĩ":"i","ī":"i","ĭ":"i","į":"i","ı":"i","Ĵ":"J","ĵ":"j","Ķ":"K","ķ":"k","ĸ":"k","Ĺ":"L","Ļ":"L","Ľ":"L","Ŀ":"L","Ł":"L","ĺ":"l","ļ":"l","ľ":"l","ŀ":"l","ł":"l","Ń":"N","Ņ":"N","Ň":"N","Ŋ":"N","ń":"n","ņ":"n","ň":"n","ŋ":"n","Ō":"O","Ŏ":"O","Ő":"O","ō":"o","ŏ":"o","ő":"o","Ŕ":"R","Ŗ":"R","Ř":"R","ŕ":"r","ŗ":"r","ř":"r","Ś":"S","Ŝ":"S","Ş":"S","Š":"S","ś":"s","ŝ":"s","ş":"s","š":"s","Ţ":"T","Ť":"T","Ŧ":"T","ţ":"t","ť":"t","ŧ":"t","Ũ":"U","Ū":"U","Ŭ":"U","Ů":"U","Ű":"U","Ų":"U","ũ":"u","ū":"u","ŭ":"u","ů":"u","ű":"u","ų":"u","Ŵ":"W","ŵ":"w","Ŷ":"Y","ŷ":"y","Ÿ":"Y","Ź":"Z","Ż":"Z","Ž":"Z","ź":"z","ż":"z","ž":"z","IJ":"IJ","ij":"ij","Œ":"Oe","œ":"oe","ʼn":"'n","ſ":"s"}),bn=fn({"&":"&","<":"<",">":">",'"':""","'":"'"});function xn(t){return"\\"+je[t]}function kn(t){return we.test(t)}function En(t){var e=-1,n=Array(t.size);return t.forEach(function(t,r){n[++e]=[r,t]}),n}function Sn(t,e){return function(n){return t(e(n))}}function jn(t,e){for(var n=-1,r=t.length,i=0,a=[];++n",""":'"',"'":"'"});var Rn=function t(e){var n,$t=(e=null==e?Ie:Rn.defaults(Ie.Object(),e,Rn.pick(Ie,xe))).Array,Jt=e.Date,Qt=e.Error,Kt=e.Function,te=e.Math,ee=e.Object,ne=e.RegExp,re=e.String,ie=e.TypeError,ae=$t.prototype,oe=Kt.prototype,se=ee.prototype,ue=e["__core-js_shared__"],le=oe.toString,ce=se.hasOwnProperty,fe=0,he=(n=/[^.]+$/.exec(ue&&ue.keys&&ue.keys.IE_PROTO||""))?"Symbol(src)_1."+n:"",pe=se.toString,de=le.call(ee),ve=Ie._,_e=ne("^"+le.call(ce).replace(Mt,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),we=Be?e.Buffer:r,je=e.Symbol,Ce=e.Uint8Array,Me=we?we.allocUnsafe:r,Re=Sn(ee.getPrototypeOf,ee),Le=ee.create,Fe=se.propertyIsEnumerable,Pe=ae.splice,nn=je?je.isConcatSpreadable:r,fn=je?je.iterator:r,Ln=je?je.toStringTag:r,Bn=function(){try{var t=Da(ee,"defineProperty");return t({},"",{}),t}catch(t){}}(),Fn=e.clearTimeout!==Ie.clearTimeout&&e.clearTimeout,Pn=Jt&&Jt.now!==Ie.Date.now&&Jt.now,On=e.setTimeout!==Ie.setTimeout&&e.setTimeout,Dn=te.ceil,Nn=te.floor,Un=ee.getOwnPropertySymbols,zn=we?we.isBuffer:r,qn=e.isFinite,Vn=ae.join,Gn=Sn(ee.keys,ee),Hn=te.max,Wn=te.min,Zn=Jt.now,Yn=e.parseInt,Xn=te.random,$n=ae.reverse,Jn=Da(e,"DataView"),Qn=Da(e,"Map"),Kn=Da(e,"Promise"),tr=Da(e,"Set"),er=Da(e,"WeakMap"),nr=Da(ee,"create"),rr=er&&new er,ir={},ar=co(Jn),or=co(Qn),sr=co(Kn),ur=co(tr),lr=co(er),cr=je?je.prototype:r,fr=cr?cr.valueOf:r,hr=cr?cr.toString:r;function pr(t){if(As(t)&&!ms(t)&&!(t instanceof mr)){if(t instanceof gr)return t;if(ce.call(t,"__wrapped__"))return fo(t)}return new gr(t)}var dr=function(){function t(){}return function(e){if(!Ts(e))return{};if(Le)return Le(e);t.prototype=e;var n=new t;return t.prototype=r,n}}();function vr(){}function gr(t,e){this.__wrapped__=t,this.__actions__=[],this.__chain__=!!e,this.__index__=0,this.__values__=r}function mr(t){this.__wrapped__=t,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=F,this.__views__=[]}function _r(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e=e?t:e)),t}function Fr(t,e,n,i,a,o){var s,u=e&c,l=e&f,p=e&h;if(n&&(s=a?n(t,i,a,o):n(t)),s!==r)return s;if(!Ts(t))return t;var d=ms(t);if(d){if(s=function(t){var e=t.length,n=new t.constructor(e);return e&&"string"==typeof t[0]&&ce.call(t,"index")&&(n.index=t.index,n.input=t.input),n}(t),!u)return na(t,s)}else{var v=za(t),g=v==W||v==Z;if(bs(t))return $i(t,u);if(v==J||v==N||g&&!a){if(s=l||g?{}:Va(t),!u)return l?function(t,e){return ra(t,Ua(t),e)}(t,function(t,e){return t&&ra(e,au(e),t)}(s,t)):function(t,e){return ra(t,Na(t),e)}(t,Ir(s,t))}else{if(!Se[v])return a?t:{};s=function(t,e,n){var r,i,a,o=t.constructor;switch(e){case ot:return Ji(t);case q:case V:return new o(+t);case st:return function(t,e){var n=e?Ji(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.byteLength)}(t,n);case ut:case lt:case ct:case ft:case ht:case pt:case dt:case vt:case gt:return Qi(t,n);case Y:return new o;case X:case et:return new o(t);case K:return(a=new(i=t).constructor(i.source,zt.exec(i))).lastIndex=i.lastIndex,a;case tt:return new o;case nt:return r=t,fr?ee(fr.call(r)):{}}}(t,v,u)}}o||(o=new xr);var m=o.get(t);if(m)return m;if(o.set(t,s),Ls(t))return t.forEach(function(r){s.add(Fr(r,e,n,r,t,o))}),s;if(Cs(t))return t.forEach(function(r,i){s.set(i,Fr(r,e,n,i,t,o))}),s;var _=d?r:(p?l?Ia:Ma:l?au:iu)(t);return He(_||t,function(r,i){_&&(r=t[i=r]),Ar(s,i,Fr(r,e,n,i,t,o))}),s}function Pr(t,e,n){var i=n.length;if(null==t)return!i;for(t=ee(t);i--;){var a=n[i],o=e[a],s=t[a];if(s===r&&!(a in t)||!o(s))return!1}return!0}function Or(t,e,n){if("function"!=typeof t)throw new ie(o);return ro(function(){t.apply(r,n)},e)}function Dr(t,e,n,r){var a=-1,o=Xe,s=!0,u=t.length,l=[],c=e.length;if(!u)return l;n&&(e=Je(e,vn(n))),r?(o=$e,s=!1):e.length>=i&&(o=mn,s=!1,e=new br(e));t:for(;++a-1},yr.prototype.set=function(t,e){var n=this.__data__,r=Cr(n,t);return r<0?(++this.size,n.push([t,e])):n[r][1]=e,this},wr.prototype.clear=function(){this.size=0,this.__data__={hash:new _r,map:new(Qn||yr),string:new _r}},wr.prototype.delete=function(t){var e=Pa(this,t).delete(t);return this.size-=e?1:0,e},wr.prototype.get=function(t){return Pa(this,t).get(t)},wr.prototype.has=function(t){return Pa(this,t).has(t)},wr.prototype.set=function(t,e){var n=Pa(this,t),r=n.size;return n.set(t,e),this.size+=n.size==r?0:1,this},br.prototype.add=br.prototype.push=function(t){return this.__data__.set(t,s),this},br.prototype.has=function(t){return this.__data__.has(t)},xr.prototype.clear=function(){this.__data__=new yr,this.size=0},xr.prototype.delete=function(t){var e=this.__data__,n=e.delete(t);return this.size=e.size,n},xr.prototype.get=function(t){return this.__data__.get(t)},xr.prototype.has=function(t){return this.__data__.has(t)},xr.prototype.set=function(t,e){var n=this.__data__;if(n instanceof yr){var r=n.__data__;if(!Qn||r.length0&&n(s)?e>1?Gr(s,e-1,n,r,i):Qe(i,s):r||(i[i.length]=s)}return i}var Hr=sa(),Wr=sa(!0);function Zr(t,e){return t&&Hr(t,e,iu)}function Yr(t,e){return t&&Wr(t,e,iu)}function Xr(t,e){return Ye(e,function(e){return Es(t[e])})}function $r(t,e){for(var n=0,i=(e=Wi(e,t)).length;null!=t&&ne}function ti(t,e){return null!=t&&ce.call(t,e)}function ei(t,e){return null!=t&&e in ee(t)}function ni(t,e,n){for(var i=n?$e:Xe,a=t[0].length,o=t.length,s=o,u=$t(o),l=1/0,c=[];s--;){var f=t[s];s&&e&&(f=Je(f,vn(e))),l=Wn(f.length,l),u[s]=!n&&(e||a>=120&&f.length>=120)?new br(s&&f):r}f=t[0];var h=-1,p=u[0];t:for(;++h=s)return u;var l=n[r];return u*("desc"==l?-1:1)}}return t.index-e.index}(t,e,n)})}function _i(t,e,n){for(var r=-1,i=e.length,a={};++r-1;)s!==t&&Pe.call(s,u,1),Pe.call(t,u,1);return t}function wi(t,e){for(var n=t?e.length:0,r=n-1;n--;){var i=e[n];if(n==r||i!==a){var a=i;Ha(i)?Pe.call(t,i,1):Di(t,i)}}return t}function bi(t,e){return t+Nn(Xn()*(e-t+1))}function xi(t,e){var n="";if(!t||e<1||e>R)return n;do{e%2&&(n+=t),(e=Nn(e/2))&&(t+=t)}while(e);return n}function ki(t,e){return io(Ka(t,e,Mu),t+"")}function Ei(t){return Er(pu(t))}function Si(t,e){var n=pu(t);return so(n,Br(e,0,n.length))}function ji(t,e,n,i){if(!Ts(t))return t;for(var a=-1,o=(e=Wi(e,t)).length,s=o-1,u=t;null!=u&&++ai?0:i+e),(n=n>i?i:n)<0&&(n+=i),i=e>n?0:n-e>>>0,e>>>=0;for(var a=$t(i);++r>>1,o=t[a];null!==o&&!Fs(o)&&(n?o<=e:o=i){var c=e?null:xa(t);if(c)return Tn(c);s=!1,a=mn,l=new br}else l=e?[]:u;t:for(;++r=i?t:Mi(t,e,n)}var Xi=Fn||function(t){return Ie.clearTimeout(t)};function $i(t,e){if(e)return t.slice();var n=t.length,r=Me?Me(n):new t.constructor(n);return t.copy(r),r}function Ji(t){var e=new t.constructor(t.byteLength);return new Ce(e).set(new Ce(t)),e}function Qi(t,e){var n=e?Ji(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.length)}function Ki(t,e){if(t!==e){var n=t!==r,i=null===t,a=t==t,o=Fs(t),s=e!==r,u=null===e,l=e==e,c=Fs(e);if(!u&&!c&&!o&&t>e||o&&s&&l&&!u&&!c||i&&s&&l||!n&&l||!a)return 1;if(!i&&!o&&!c&&t1?n[a-1]:r,s=a>2?n[2]:r;for(o=t.length>3&&"function"==typeof o?(a--,o):r,s&&Wa(n[0],n[1],s)&&(o=a<3?r:o,a=1),e=ee(e);++i-1?a[o?e[s]:s]:r}}function ha(t){return Ca(function(e){var n=e.length,i=n,a=gr.prototype.thru;for(t&&e.reverse();i--;){var s=e[i];if("function"!=typeof s)throw new ie(o);if(a&&!u&&"wrapper"==La(s))var u=new gr([],!0)}for(i=u?i:n;++i1&&_.reverse(),f&&lu))return!1;var c=o.get(t);if(c&&o.get(e))return c==e;var f=-1,h=!0,v=n&d?new br:r;for(o.set(t,e),o.set(e,t);++f-1&&t%1==0&&t1?"& ":"")+e[r],e=e.join(n>2?", ":" "),t.replace(Ft,"{\n/* [wrapped with "+e+"] */\n")}(r,function(t,e){return He(D,function(n){var r="_."+n[0];e&n[1]&&!Xe(t,r)&&t.push(r)}),t.sort()}(function(t){var e=t.match(Pt);return e?e[1].split(Ot):[]}(r),n)))}function oo(t){var e=0,n=0;return function(){var i=Zn(),a=A-(i-n);if(n=i,a>0){if(++e>=T)return arguments[0]}else e=0;return t.apply(r,arguments)}}function so(t,e){var n=-1,i=t.length,a=i-1;for(e=e===r?i:e;++n1?t[e-1]:r;return Ro(t,n="function"==typeof n?(t.pop(),n):r)});function No(t){var e=pr(t);return e.__chain__=!0,e}function Uo(t,e){return e(t)}var zo=Ca(function(t){var e=t.length,n=e?t[0]:0,i=this.__wrapped__,a=function(e){return Lr(e,t)};return!(e>1||this.__actions__.length)&&i instanceof mr&&Ha(n)?((i=i.slice(n,+n+(e?1:0))).__actions__.push({func:Uo,args:[a],thisArg:r}),new gr(i,this.__chain__).thru(function(t){return e&&!t.length&&t.push(r),t})):this.thru(a)});var qo=ia(function(t,e,n){ce.call(t,n)?++t[n]:Rr(t,n,1)});var Vo=fa(go),Go=fa(mo);function Ho(t,e){return(ms(t)?He:Nr)(t,Fa(e,3))}function Wo(t,e){return(ms(t)?We:Ur)(t,Fa(e,3))}var Zo=ia(function(t,e,n){ce.call(t,n)?t[n].push(e):Rr(t,n,[e])});var Yo=ki(function(t,e,n){var r=-1,i="function"==typeof e,a=ys(t)?$t(t.length):[];return Nr(t,function(t){a[++r]=i?Ve(e,t,n):ri(t,e,n)}),a}),Xo=ia(function(t,e,n){Rr(t,n,e)});function $o(t,e){return(ms(t)?Je:hi)(t,Fa(e,3))}var Jo=ia(function(t,e,n){t[n?0:1].push(e)},function(){return[[],[]]});var Qo=ki(function(t,e){if(null==t)return[];var n=e.length;return n>1&&Wa(t,e[0],e[1])?e=[]:n>2&&Wa(e[0],e[1],e[2])&&(e=[e[0]]),mi(t,Gr(e,1),[])}),Ko=Pn||function(){return Ie.Date.now()};function ts(t,e,n){return e=n?r:e,e=t&&null==e?t.length:e,Ea(t,x,r,r,r,r,e)}function es(t,e){var n;if("function"!=typeof e)throw new ie(o);return t=zs(t),function(){return--t>0&&(n=e.apply(this,arguments)),t<=1&&(e=r),n}}var ns=ki(function(t,e,n){var r=v;if(n.length){var i=jn(n,Ba(ns));r|=w}return Ea(t,r,e,n,i)}),rs=ki(function(t,e,n){var r=v|g;if(n.length){var i=jn(n,Ba(rs));r|=w}return Ea(e,r,t,n,i)});function is(t,e,n){var i,a,s,u,l,c,f=0,h=!1,p=!1,d=!0;if("function"!=typeof t)throw new ie(o);function v(e){var n=i,o=a;return i=a=r,f=e,u=t.apply(o,n)}function g(t){var n=t-c;return c===r||n>=e||n<0||p&&t-f>=s}function m(){var t=Ko();if(g(t))return _(t);l=ro(m,function(t){var n=e-(t-c);return p?Wn(n,s-(t-f)):n}(t))}function _(t){return l=r,d&&i?v(t):(i=a=r,u)}function y(){var t=Ko(),n=g(t);if(i=arguments,a=this,c=t,n){if(l===r)return function(t){return f=t,l=ro(m,e),h?v(t):u}(c);if(p)return l=ro(m,e),v(c)}return l===r&&(l=ro(m,e)),u}return e=Vs(e)||0,Ts(n)&&(h=!!n.leading,s=(p="maxWait"in n)?Hn(Vs(n.maxWait)||0,e):s,d="trailing"in n?!!n.trailing:d),y.cancel=function(){l!==r&&Xi(l),f=0,i=c=a=l=r},y.flush=function(){return l===r?u:_(Ko())},y}var as=ki(function(t,e){return Or(t,1,e)}),os=ki(function(t,e,n){return Or(t,Vs(e)||0,n)});function ss(t,e){if("function"!=typeof t||null!=e&&"function"!=typeof e)throw new ie(o);var n=function(){var r=arguments,i=e?e.apply(this,r):r[0],a=n.cache;if(a.has(i))return a.get(i);var o=t.apply(this,r);return n.cache=a.set(i,o)||a,o};return n.cache=new(ss.Cache||wr),n}function us(t){if("function"!=typeof t)throw new ie(o);return function(){var e=arguments;switch(e.length){case 0:return!t.call(this);case 1:return!t.call(this,e[0]);case 2:return!t.call(this,e[0],e[1]);case 3:return!t.call(this,e[0],e[1],e[2])}return!t.apply(this,e)}}ss.Cache=wr;var ls=Zi(function(t,e){var n=(e=1==e.length&&ms(e[0])?Je(e[0],vn(Fa())):Je(Gr(e,1),vn(Fa()))).length;return ki(function(r){for(var i=-1,a=Wn(r.length,n);++i=e}),gs=ii(function(){return arguments}())?ii:function(t){return As(t)&&ce.call(t,"callee")&&!Fe.call(t,"callee")},ms=$t.isArray,_s=Oe?vn(Oe):function(t){return As(t)&&Qr(t)==ot};function ys(t){return null!=t&&js(t.length)&&!Es(t)}function ws(t){return As(t)&&ys(t)}var bs=zn||Vu,xs=De?vn(De):function(t){return As(t)&&Qr(t)==V};function ks(t){if(!As(t))return!1;var e=Qr(t);return e==H||e==G||"string"==typeof t.message&&"string"==typeof t.name&&!Is(t)}function Es(t){if(!Ts(t))return!1;var e=Qr(t);return e==W||e==Z||e==z||e==Q}function Ss(t){return"number"==typeof t&&t==zs(t)}function js(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=R}function Ts(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}function As(t){return null!=t&&"object"==typeof t}var Cs=Ne?vn(Ne):function(t){return As(t)&&za(t)==Y};function Ms(t){return"number"==typeof t||As(t)&&Qr(t)==X}function Is(t){if(!As(t)||Qr(t)!=J)return!1;var e=Re(t);if(null===e)return!0;var n=ce.call(e,"constructor")&&e.constructor;return"function"==typeof n&&n instanceof n&&le.call(n)==de}var Rs=Ue?vn(Ue):function(t){return As(t)&&Qr(t)==K};var Ls=ze?vn(ze):function(t){return As(t)&&za(t)==tt};function Bs(t){return"string"==typeof t||!ms(t)&&As(t)&&Qr(t)==et}function Fs(t){return"symbol"==typeof t||As(t)&&Qr(t)==nt}var Ps=qe?vn(qe):function(t){return As(t)&&js(t.length)&&!!Ee[Qr(t)]};var Os=ya(fi),Ds=ya(function(t,e){return t<=e});function Ns(t){if(!t)return[];if(ys(t))return Bs(t)?Mn(t):na(t);if(fn&&t[fn])return function(t){for(var e,n=[];!(e=t.next()).done;)n.push(e.value);return n}(t[fn]());var e=za(t);return(e==Y?En:e==tt?Tn:pu)(t)}function Us(t){return t?(t=Vs(t))===I||t===-I?(t<0?-1:1)*L:t==t?t:0:0===t?t:0}function zs(t){var e=Us(t),n=e%1;return e==e?n?e-n:e:0}function qs(t){return t?Br(zs(t),0,F):0}function Vs(t){if("number"==typeof t)return t;if(Fs(t))return B;if(Ts(t)){var e="function"==typeof t.valueOf?t.valueOf():t;t=Ts(e)?e+"":e}if("string"!=typeof t)return 0===t?t:+t;t=t.replace(Rt,"");var n=Vt.test(t);return n||Ht.test(t)?Ae(t.slice(2),n?2:8):qt.test(t)?B:+t}function Gs(t){return ra(t,au(t))}function Hs(t){return null==t?"":Pi(t)}var Ws=aa(function(t,e){if($a(e)||ys(e))ra(e,iu(e),t);else for(var n in e)ce.call(e,n)&&Ar(t,n,e[n])}),Zs=aa(function(t,e){ra(e,au(e),t)}),Ys=aa(function(t,e,n,r){ra(e,au(e),t,r)}),Xs=aa(function(t,e,n,r){ra(e,iu(e),t,r)}),$s=Ca(Lr);var Js=ki(function(t,e){t=ee(t);var n=-1,i=e.length,a=i>2?e[2]:r;for(a&&Wa(e[0],e[1],a)&&(i=1);++n1),e}),ra(t,Ia(t),n),r&&(n=Fr(n,c|f|h,Ta));for(var i=e.length;i--;)Di(n,e[i]);return n});var lu=Ca(function(t,e){return null==t?{}:function(t,e){return _i(t,e,function(e,n){return tu(t,n)})}(t,e)});function cu(t,e){if(null==t)return{};var n=Je(Ia(t),function(t){return[t]});return e=Fa(e),_i(t,n,function(t,n){return e(t,n[0])})}var fu=ka(iu),hu=ka(au);function pu(t){return null==t?[]:gn(t,iu(t))}var du=la(function(t,e,n){return e=e.toLowerCase(),t+(n?vu(e):e)});function vu(t){return ku(Hs(t).toLowerCase())}function gu(t){return(t=Hs(t))&&t.replace(Zt,wn).replace(me,"")}var mu=la(function(t,e,n){return t+(n?"-":"")+e.toLowerCase()}),_u=la(function(t,e,n){return t+(n?" ":"")+e.toLowerCase()}),yu=ua("toLowerCase");var wu=la(function(t,e,n){return t+(n?"_":"")+e.toLowerCase()});var bu=la(function(t,e,n){return t+(n?" ":"")+ku(e)});var xu=la(function(t,e,n){return t+(n?" ":"")+e.toUpperCase()}),ku=ua("toUpperCase");function Eu(t,e,n){return t=Hs(t),(e=n?r:e)===r?function(t){return be.test(t)}(t)?function(t){return t.match(ye)||[]}(t):function(t){return t.match(Dt)||[]}(t):t.match(e)||[]}var Su=ki(function(t,e){try{return Ve(t,r,e)}catch(t){return ks(t)?t:new Qt(t)}}),ju=Ca(function(t,e){return He(e,function(e){e=lo(e),Rr(t,e,ns(t[e],t))}),t});function Tu(t){return function(){return t}}var Au=ha(),Cu=ha(!0);function Mu(t){return t}function Iu(t){return ui("function"==typeof t?t:Fr(t,c))}var Ru=ki(function(t,e){return function(n){return ri(n,t,e)}}),Lu=ki(function(t,e){return function(n){return ri(t,n,e)}});function Bu(t,e,n){var r=iu(e),i=Xr(e,r);null!=n||Ts(e)&&(i.length||!r.length)||(n=e,e=t,t=this,i=Xr(e,iu(e)));var a=!(Ts(n)&&"chain"in n&&!n.chain),o=Es(t);return He(i,function(n){var r=e[n];t[n]=r,o&&(t.prototype[n]=function(){var e=this.__chain__;if(a||e){var n=t(this.__wrapped__);return(n.__actions__=na(this.__actions__)).push({func:r,args:arguments,thisArg:t}),n.__chain__=e,n}return r.apply(t,Qe([this.value()],arguments))})}),t}function Fu(){}var Pu=ga(Je),Ou=ga(Ze),Du=ga(en);function Nu(t){return Za(t)?cn(lo(t)):function(t){return function(e){return $r(e,t)}}(t)}var Uu=_a(),zu=_a(!0);function qu(){return[]}function Vu(){return!1}var Gu=va(function(t,e){return t+e},0),Hu=ba("ceil"),Wu=va(function(t,e){return t/e},1),Zu=ba("floor");var Yu,Xu=va(function(t,e){return t*e},1),$u=ba("round"),Ju=va(function(t,e){return t-e},0);return pr.after=function(t,e){if("function"!=typeof e)throw new ie(o);return t=zs(t),function(){if(--t<1)return e.apply(this,arguments)}},pr.ary=ts,pr.assign=Ws,pr.assignIn=Zs,pr.assignInWith=Ys,pr.assignWith=Xs,pr.at=$s,pr.before=es,pr.bind=ns,pr.bindAll=ju,pr.bindKey=rs,pr.castArray=function(){if(!arguments.length)return[];var t=arguments[0];return ms(t)?t:[t]},pr.chain=No,pr.chunk=function(t,e,n){e=(n?Wa(t,e,n):e===r)?1:Hn(zs(e),0);var i=null==t?0:t.length;if(!i||e<1)return[];for(var a=0,o=0,s=$t(Dn(i/e));aa?0:a+n),(i=i===r||i>a?a:zs(i))<0&&(i+=a),i=n>i?0:qs(i);n>>0)?(t=Hs(t))&&("string"==typeof e||null!=e&&!Rs(e))&&!(e=Pi(e))&&kn(t)?Yi(Mn(t),0,n):t.split(e,n):[]},pr.spread=function(t,e){if("function"!=typeof t)throw new ie(o);return e=null==e?0:Hn(zs(e),0),ki(function(n){var r=n[e],i=Yi(n,0,e);return r&&Qe(i,r),Ve(t,this,i)})},pr.tail=function(t){var e=null==t?0:t.length;return e?Mi(t,1,e):[]},pr.take=function(t,e,n){return t&&t.length?Mi(t,0,(e=n||e===r?1:zs(e))<0?0:e):[]},pr.takeRight=function(t,e,n){var i=null==t?0:t.length;return i?Mi(t,(e=i-(e=n||e===r?1:zs(e)))<0?0:e,i):[]},pr.takeRightWhile=function(t,e){return t&&t.length?Ui(t,Fa(e,3),!1,!0):[]},pr.takeWhile=function(t,e){return t&&t.length?Ui(t,Fa(e,3)):[]},pr.tap=function(t,e){return e(t),t},pr.throttle=function(t,e,n){var r=!0,i=!0;if("function"!=typeof t)throw new ie(o);return Ts(n)&&(r="leading"in n?!!n.leading:r,i="trailing"in n?!!n.trailing:i),is(t,e,{leading:r,maxWait:e,trailing:i})},pr.thru=Uo,pr.toArray=Ns,pr.toPairs=fu,pr.toPairsIn=hu,pr.toPath=function(t){return ms(t)?Je(t,lo):Fs(t)?[t]:na(uo(Hs(t)))},pr.toPlainObject=Gs,pr.transform=function(t,e,n){var r=ms(t),i=r||bs(t)||Ps(t);if(e=Fa(e,4),null==n){var a=t&&t.constructor;n=i?r?new a:[]:Ts(t)&&Es(a)?dr(Re(t)):{}}return(i?He:Zr)(t,function(t,r,i){return e(n,t,r,i)}),n},pr.unary=function(t){return ts(t,1)},pr.union=Ao,pr.unionBy=Co,pr.unionWith=Mo,pr.uniq=function(t){return t&&t.length?Oi(t):[]},pr.uniqBy=function(t,e){return t&&t.length?Oi(t,Fa(e,2)):[]},pr.uniqWith=function(t,e){return e="function"==typeof e?e:r,t&&t.length?Oi(t,r,e):[]},pr.unset=function(t,e){return null==t||Di(t,e)},pr.unzip=Io,pr.unzipWith=Ro,pr.update=function(t,e,n){return null==t?t:Ni(t,e,Hi(n))},pr.updateWith=function(t,e,n,i){return i="function"==typeof i?i:r,null==t?t:Ni(t,e,Hi(n),i)},pr.values=pu,pr.valuesIn=function(t){return null==t?[]:gn(t,au(t))},pr.without=Lo,pr.words=Eu,pr.wrap=function(t,e){return cs(Hi(e),t)},pr.xor=Bo,pr.xorBy=Fo,pr.xorWith=Po,pr.zip=Oo,pr.zipObject=function(t,e){return Vi(t||[],e||[],Ar)},pr.zipObjectDeep=function(t,e){return Vi(t||[],e||[],ji)},pr.zipWith=Do,pr.entries=fu,pr.entriesIn=hu,pr.extend=Zs,pr.extendWith=Ys,Bu(pr,pr),pr.add=Gu,pr.attempt=Su,pr.camelCase=du,pr.capitalize=vu,pr.ceil=Hu,pr.clamp=function(t,e,n){return n===r&&(n=e,e=r),n!==r&&(n=(n=Vs(n))==n?n:0),e!==r&&(e=(e=Vs(e))==e?e:0),Br(Vs(t),e,n)},pr.clone=function(t){return Fr(t,h)},pr.cloneDeep=function(t){return Fr(t,c|h)},pr.cloneDeepWith=function(t,e){return Fr(t,c|h,e="function"==typeof e?e:r)},pr.cloneWith=function(t,e){return Fr(t,h,e="function"==typeof e?e:r)},pr.conformsTo=function(t,e){return null==e||Pr(t,e,iu(e))},pr.deburr=gu,pr.defaultTo=function(t,e){return null==t||t!=t?e:t},pr.divide=Wu,pr.endsWith=function(t,e,n){t=Hs(t),e=Pi(e);var i=t.length,a=n=n===r?i:Br(zs(n),0,i);return(n-=e.length)>=0&&t.slice(n,a)==e},pr.eq=ps,pr.escape=function(t){return(t=Hs(t))&&kt.test(t)?t.replace(bt,bn):t},pr.escapeRegExp=function(t){return(t=Hs(t))&&It.test(t)?t.replace(Mt,"\\$&"):t},pr.every=function(t,e,n){var i=ms(t)?Ze:zr;return n&&Wa(t,e,n)&&(e=r),i(t,Fa(e,3))},pr.find=Vo,pr.findIndex=go,pr.findKey=function(t,e){return rn(t,Fa(e,3),Zr)},pr.findLast=Go,pr.findLastIndex=mo,pr.findLastKey=function(t,e){return rn(t,Fa(e,3),Yr)},pr.floor=Zu,pr.forEach=Ho,pr.forEachRight=Wo,pr.forIn=function(t,e){return null==t?t:Hr(t,Fa(e,3),au)},pr.forInRight=function(t,e){return null==t?t:Wr(t,Fa(e,3),au)},pr.forOwn=function(t,e){return t&&Zr(t,Fa(e,3))},pr.forOwnRight=function(t,e){return t&&Yr(t,Fa(e,3))},pr.get=Ks,pr.gt=ds,pr.gte=vs,pr.has=function(t,e){return null!=t&&qa(t,e,ti)},pr.hasIn=tu,pr.head=yo,pr.identity=Mu,pr.includes=function(t,e,n,r){t=ys(t)?t:pu(t),n=n&&!r?zs(n):0;var i=t.length;return n<0&&(n=Hn(i+n,0)),Bs(t)?n<=i&&t.indexOf(e,n)>-1:!!i&&on(t,e,n)>-1},pr.indexOf=function(t,e,n){var r=null==t?0:t.length;if(!r)return-1;var i=null==n?0:zs(n);return i<0&&(i=Hn(r+i,0)),on(t,e,i)},pr.inRange=function(t,e,n){return e=Us(e),n===r?(n=e,e=0):n=Us(n),function(t,e,n){return t>=Wn(e,n)&&t=-R&&t<=R},pr.isSet=Ls,pr.isString=Bs,pr.isSymbol=Fs,pr.isTypedArray=Ps,pr.isUndefined=function(t){return t===r},pr.isWeakMap=function(t){return As(t)&&za(t)==it},pr.isWeakSet=function(t){return As(t)&&Qr(t)==at},pr.join=function(t,e){return null==t?"":Vn.call(t,e)},pr.kebabCase=mu,pr.last=ko,pr.lastIndexOf=function(t,e,n){var i=null==t?0:t.length;if(!i)return-1;var a=i;return n!==r&&(a=(a=zs(n))<0?Hn(i+a,0):Wn(a,i-1)),e==e?function(t,e,n){for(var r=n+1;r--;)if(t[r]===e)return r;return r}(t,e,a):an(t,un,a,!0)},pr.lowerCase=_u,pr.lowerFirst=yu,pr.lt=Os,pr.lte=Ds,pr.max=function(t){return t&&t.length?qr(t,Mu,Kr):r},pr.maxBy=function(t,e){return t&&t.length?qr(t,Fa(e,2),Kr):r},pr.mean=function(t){return ln(t,Mu)},pr.meanBy=function(t,e){return ln(t,Fa(e,2))},pr.min=function(t){return t&&t.length?qr(t,Mu,fi):r},pr.minBy=function(t,e){return t&&t.length?qr(t,Fa(e,2),fi):r},pr.stubArray=qu,pr.stubFalse=Vu,pr.stubObject=function(){return{}},pr.stubString=function(){return""},pr.stubTrue=function(){return!0},pr.multiply=Xu,pr.nth=function(t,e){return t&&t.length?gi(t,zs(e)):r},pr.noConflict=function(){return Ie._===this&&(Ie._=ve),this},pr.noop=Fu,pr.now=Ko,pr.pad=function(t,e,n){t=Hs(t);var r=(e=zs(e))?Cn(t):0;if(!e||r>=e)return t;var i=(e-r)/2;return ma(Nn(i),n)+t+ma(Dn(i),n)},pr.padEnd=function(t,e,n){t=Hs(t);var r=(e=zs(e))?Cn(t):0;return e&&re){var i=t;t=e,e=i}if(n||t%1||e%1){var a=Xn();return Wn(t+a*(e-t+Te("1e-"+((a+"").length-1))),e)}return bi(t,e)},pr.reduce=function(t,e,n){var r=ms(t)?Ke:hn,i=arguments.length<3;return r(t,Fa(e,4),n,i,Nr)},pr.reduceRight=function(t,e,n){var r=ms(t)?tn:hn,i=arguments.length<3;return r(t,Fa(e,4),n,i,Ur)},pr.repeat=function(t,e,n){return e=(n?Wa(t,e,n):e===r)?1:zs(e),xi(Hs(t),e)},pr.replace=function(){var t=arguments,e=Hs(t[0]);return t.length<3?e:e.replace(t[1],t[2])},pr.result=function(t,e,n){var i=-1,a=(e=Wi(e,t)).length;for(a||(a=1,t=r);++iR)return[];var n=F,r=Wn(t,F);e=Fa(e),t-=F;for(var i=dn(r,e);++n=o)return t;var u=n-Cn(i);if(u<1)return i;var l=s?Yi(s,0,u).join(""):t.slice(0,u);if(a===r)return l+i;if(s&&(u+=l.length-u),Rs(a)){if(t.slice(u).search(a)){var c,f=l;for(a.global||(a=ne(a.source,Hs(zt.exec(a))+"g")),a.lastIndex=0;c=a.exec(f);)var h=c.index;l=l.slice(0,h===r?u:h)}}else if(t.indexOf(Pi(a),u)!=u){var p=l.lastIndexOf(a);p>-1&&(l=l.slice(0,p))}return l+i},pr.unescape=function(t){return(t=Hs(t))&&xt.test(t)?t.replace(wt,In):t},pr.uniqueId=function(t){var e=++fe;return Hs(t)+e},pr.upperCase=xu,pr.upperFirst=ku,pr.each=Ho,pr.eachRight=Wo,pr.first=yo,Bu(pr,(Yu={},Zr(pr,function(t,e){ce.call(pr.prototype,e)||(Yu[e]=t)}),Yu),{chain:!1}),pr.VERSION="4.17.11",He(["bind","bindKey","curry","curryRight","partial","partialRight"],function(t){pr[t].placeholder=pr}),He(["drop","take"],function(t,e){mr.prototype[t]=function(n){n=n===r?1:Hn(zs(n),0);var i=this.__filtered__&&!e?new mr(this):this.clone();return i.__filtered__?i.__takeCount__=Wn(n,i.__takeCount__):i.__views__.push({size:Wn(n,F),type:t+(i.__dir__<0?"Right":"")}),i},mr.prototype[t+"Right"]=function(e){return this.reverse()[t](e).reverse()}}),He(["filter","map","takeWhile"],function(t,e){var n=e+1,r=n==C||3==n;mr.prototype[t]=function(t){var e=this.clone();return e.__iteratees__.push({iteratee:Fa(t,3),type:n}),e.__filtered__=e.__filtered__||r,e}}),He(["head","last"],function(t,e){var n="take"+(e?"Right":"");mr.prototype[t]=function(){return this[n](1).value()[0]}}),He(["initial","tail"],function(t,e){var n="drop"+(e?"":"Right");mr.prototype[t]=function(){return this.__filtered__?new mr(this):this[n](1)}}),mr.prototype.compact=function(){return this.filter(Mu)},mr.prototype.find=function(t){return this.filter(t).head()},mr.prototype.findLast=function(t){return this.reverse().find(t)},mr.prototype.invokeMap=ki(function(t,e){return"function"==typeof t?new mr(this):this.map(function(n){return ri(n,t,e)})}),mr.prototype.reject=function(t){return this.filter(us(Fa(t)))},mr.prototype.slice=function(t,e){t=zs(t);var n=this;return n.__filtered__&&(t>0||e<0)?new mr(n):(t<0?n=n.takeRight(-t):t&&(n=n.drop(t)),e!==r&&(n=(e=zs(e))<0?n.dropRight(-e):n.take(e-t)),n)},mr.prototype.takeRightWhile=function(t){return this.reverse().takeWhile(t).reverse()},mr.prototype.toArray=function(){return this.take(F)},Zr(mr.prototype,function(t,e){var n=/^(?:filter|find|map|reject)|While$/.test(e),i=/^(?:head|last)$/.test(e),a=pr[i?"take"+("last"==e?"Right":""):e],o=i||/^find/.test(e);a&&(pr.prototype[e]=function(){var e=this.__wrapped__,s=i?[1]:arguments,u=e instanceof mr,l=s[0],c=u||ms(e),f=function(t){var e=a.apply(pr,Qe([t],s));return i&&h?e[0]:e};c&&n&&"function"==typeof l&&1!=l.length&&(u=c=!1);var h=this.__chain__,p=!!this.__actions__.length,d=o&&!h,v=u&&!p;if(!o&&c){e=v?e:new mr(this);var g=t.apply(e,s);return g.__actions__.push({func:Uo,args:[f],thisArg:r}),new gr(g,h)}return d&&v?t.apply(this,s):(g=this.thru(f),d?i?g.value()[0]:g.value():g)})}),He(["pop","push","shift","sort","splice","unshift"],function(t){var e=ae[t],n=/^(?:push|sort|unshift)$/.test(t)?"tap":"thru",r=/^(?:pop|shift)$/.test(t);pr.prototype[t]=function(){var t=arguments;if(r&&!this.__chain__){var i=this.value();return e.apply(ms(i)?i:[],t)}return this[n](function(n){return e.apply(ms(n)?n:[],t)})}}),Zr(mr.prototype,function(t,e){var n=pr[e];if(n){var r=n.name+"";(ir[r]||(ir[r]=[])).push({name:e,func:n})}}),ir[pa(r,g).name]=[{name:"wrapper",func:r}],mr.prototype.clone=function(){var t=new mr(this.__wrapped__);return t.__actions__=na(this.__actions__),t.__dir__=this.__dir__,t.__filtered__=this.__filtered__,t.__iteratees__=na(this.__iteratees__),t.__takeCount__=this.__takeCount__,t.__views__=na(this.__views__),t},mr.prototype.reverse=function(){if(this.__filtered__){var t=new mr(this);t.__dir__=-1,t.__filtered__=!0}else(t=this.clone()).__dir__*=-1;return t},mr.prototype.value=function(){var t=this.__wrapped__.value(),e=this.__dir__,n=ms(t),r=e<0,i=n?t.length:0,a=function(t,e,n){for(var r=-1,i=n.length;++r=this.__values__.length;return{done:t,value:t?r:this.__values__[this.__index__++]}},pr.prototype.plant=function(t){for(var e,n=this;n instanceof vr;){var i=fo(n);i.__index__=0,i.__values__=r,e?a.__wrapped__=i:e=i;var a=i;n=n.__wrapped__}return a.__wrapped__=t,e},pr.prototype.reverse=function(){var t=this.__wrapped__;if(t instanceof mr){var e=t;return this.__actions__.length&&(e=new mr(this)),(e=e.reverse()).__actions__.push({func:Uo,args:[To],thisArg:r}),new gr(e,this.__chain__)}return this.thru(To)},pr.prototype.toJSON=pr.prototype.valueOf=pr.prototype.value=function(){return zi(this.__wrapped__,this.__actions__)},pr.prototype.first=pr.prototype.head,fn&&(pr.prototype[fn]=function(){return this}),pr}();"function"==typeof define&&"object"==typeof define.amd&&define.amd?(Ie._=Rn,define(function(){return Rn})):Le?((Le.exports=Rn)._=Rn,Re._=Rn):Ie._=Rn}).call(this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],76:[function(t,e,n){(function(n){t("path");var r=t("fs");function i(){this.types=Object.create(null),this.extensions=Object.create(null)}i.prototype.define=function(t){for(var e in t){for(var r=t[e],i=0;i=0;--s)if(h[s]=f,f*=l[s],p=Math.max(p,o.scratchMemory(l[s])),e.shape[s]!==n.shape[s])throw new Error("Shape mismatch, real and imaginary arrays must have same size");var d,v=4*f+p;d="array"===e.dtype||"float64"===e.dtype||"custom"===e.dtype?a.mallocDouble(v):a.mallocFloat(v);var g,m,_,y,w=i(d,l.slice(0),h,0),b=i(d,l.slice(0),h.slice(0),f),x=i(d,l.slice(0),h.slice(0),2*f),k=i(d,l.slice(0),h.slice(0),3*f),E=4*f;for(r.assign(w,e),r.assign(b,n),s=c-1;s>=0&&(o(t,f/l[s],l[s],d,w.offset,b.offset,E),0!==s);--s){for(m=1,_=x.stride,y=k.stride,u=s-1;u=0;--u)y[u]=_[u]=m,m*=l[u];r.assign(x,w),r.assign(k,b),g=w,w=x,x=g,g=b,b=k,k=g}r.assign(e,w),r.assign(n,b),a.free(d)}},{"./lib/fft-matrix.js":79,ndarray:84,"ndarray-ops":81,"typedarray-pool":144}],79:[function(t,e,n){var r=t("bit-twiddle");function i(t,e,n,i,a,o){var s,u,l,c,f,h,p,d,v,g,m,_,y,w,b,x,k,E,S,j,T,A,C,M;for(t|=0,e|=0,a|=0,o|=0,s=n|=0,u=r.log2(s),E=0;E>1,f=0,l=0;l>=1;f+=h}for(m=-1,_=0,g=1,d=0;d>",rrshift:">>>"};!function(){for(var t in s){var e=s[t];n[t]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+e+"c"},funcName:t}),n[t+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a"+e+"=b"},rvalue:!0,funcName:t+"eq"}),n[t+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+e+"s"},funcName:t+"s"}),n[t+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a"+e+"=s"},rvalue:!0,funcName:t+"seq"})}}();var u={not:"!",bnot:"~",neg:"-",recip:"1.0/"};!function(){for(var t in u){var e=u[t];n[t]=o({args:["array","array"],body:{args:["a","b"],body:"a="+e+"b"},funcName:t}),n[t+"eq"]=o({args:["array"],body:{args:["a"],body:"a="+e+"a"},rvalue:!0,count:2,funcName:t+"eq"})}}();var l={and:"&&",or:"||",eq:"===",neq:"!==",lt:"<",gt:">",leq:"<=",geq:">="};!function(){for(var t in l){var e=l[t];n[t]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+e+"c"},funcName:t}),n[t+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+e+"s"},funcName:t+"s"}),n[t+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a=a"+e+"b"},rvalue:!0,count:2,funcName:t+"eq"}),n[t+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a=a"+e+"s"},rvalue:!0,count:2,funcName:t+"seq"})}}();var c=["abs","acos","asin","atan","ceil","cos","exp","floor","log","round","sin","sqrt","tan"];!function(){for(var t=0;tthis_s){this_s=-a}else if(a>this_s){this_s=a}",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norminf"}),n.norm1=r({args:["array"],pre:{args:[],localVars:[],thisVars:["this_s"],body:"this_s=0"},body:{args:[{name:"a",lvalue:!1,rvalue:!0,count:3}],body:"this_s+=a<0?-a:a",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norm1"}),n.sup=r({args:["array"],pre:{body:"this_h=-Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_>this_h)this_h=_inline_1_arg0_",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_h"],localVars:[]},post:{body:"return this_h",args:[],thisVars:["this_h"],localVars:[]}}),n.inf=r({args:["array"],pre:{body:"this_h=Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_this_v){this_v=_inline_1_arg1_;for(var _inline_1_k=0;_inline_1_k<_inline_1_arg0_.length;++_inline_1_k){this_i[_inline_1_k]=_inline_1_arg0_[_inline_1_k]}}}",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_i","this_v"],localVars:["_inline_1_k"]},post:{body:"{return this_i}",args:[],thisVars:["this_i"],localVars:[]}}),n.random=o({args:["array"],pre:{args:[],body:"this_f=Math.random",thisVars:["this_f"]},body:{args:["a"],body:"a=this_f()",thisVars:["this_f"]},funcName:"random"}),n.assign=o({args:["array","array"],body:{args:["a","b"],body:"a=b"},funcName:"assign"}),n.assigns=o({args:["array","scalar"],body:{args:["a","b"],body:"a=b"},funcName:"assigns"}),n.equals=r({args:["array","array"],pre:i,body:{args:[{name:"x",lvalue:!1,rvalue:!0,count:1},{name:"y",lvalue:!1,rvalue:!0,count:1}],body:"if(x!==y){return false}",localVars:[],thisVars:[]},post:{args:[],localVars:[],thisVars:[],body:"return true"},funcName:"equals"})},{"cwise-compiler":16}],82:[function(t,e,n){"use strict";var r=t("ndarray"),i=t("./doConvert.js");e.exports=function(t,e){for(var n=[],a=t,o=1;Array.isArray(a);)n.push(a.length),o*=a.length,a=a[0];return 0===n.length?r():(e||(e=r(new Float64Array(o),n)),i(e,t),e)}},{"./doConvert.js":83,ndarray:84}],83:[function(t,e,n){e.exports=t("cwise-compiler")({args:["array","scalar","index"],pre:{body:"{}",args:[],thisVars:[],localVars:[]},body:{body:"{\nvar _inline_1_v=_inline_1_arg1_,_inline_1_i\nfor(_inline_1_i=0;_inline_1_i<_inline_1_arg2_.length-1;++_inline_1_i) {\n_inline_1_v=_inline_1_v[_inline_1_arg2_[_inline_1_i]]\n}\n_inline_1_arg0_=_inline_1_v[_inline_1_arg2_[_inline_1_arg2_.length-1]]\n}",args:[{name:"_inline_1_arg0_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg2_",lvalue:!1,rvalue:!0,count:4}],thisVars:[],localVars:["_inline_1_i","_inline_1_v"]},post:{body:"{}",args:[],thisVars:[],localVars:[]},funcName:"convert",blockSize:64})},{"cwise-compiler":16}],84:[function(t,e,n){var r=t("iota-array"),i=t("is-buffer"),a="undefined"!=typeof Float64Array;function o(t,e){return t[0]-e[0]}function s(){var t,e=this.stride,n=new Array(e.length);for(t=0;tMath.abs(this.stride[1]))?[1,0]:[0,1]}})"):3===e&&a.push("var s0=Math.abs(this.stride[0]),s1=Math.abs(this.stride[1]),s2=Math.abs(this.stride[2]);if(s0>s1){if(s1>s2){return [2,1,0];}else if(s0>s2){return [1,2,0];}else{return [1,0,2];}}else if(s0>s2){return [2,0,1];}else if(s2>s1){return [0,1,2];}else{return [0,2,1];}}})")):a.push("ORDER})")),a.push("proto.set=function "+n+"_set("+u.join(",")+",v){"),i?a.push("return this.data.set("+c+",v)}"):a.push("return this.data["+c+"]=v}"),a.push("proto.get=function "+n+"_get("+u.join(",")+"){"),i?a.push("return this.data.get("+c+")}"):a.push("return this.data["+c+"]}"),a.push("proto.index=function "+n+"_index(",u.join(),"){return "+c+"}"),a.push("proto.hi=function "+n+"_hi("+u.join(",")+"){return new "+n+"(this.data,"+o.map(function(t){return["(typeof i",t,"!=='number'||i",t,"<0)?this.shape[",t,"]:i",t,"|0"].join("")}).join(",")+","+o.map(function(t){return"this.stride["+t+"]"}).join(",")+",this.offset)}");var p=o.map(function(t){return"a"+t+"=this.shape["+t+"]"}),d=o.map(function(t){return"c"+t+"=this.stride["+t+"]"});a.push("proto.lo=function "+n+"_lo("+u.join(",")+"){var b=this.offset,d=0,"+p.join(",")+","+d.join(","));for(var v=0;v=0){d=i"+v+"|0;b+=c"+v+"*d;a"+v+"-=d}");a.push("return new "+n+"(this.data,"+o.map(function(t){return"a"+t}).join(",")+","+o.map(function(t){return"c"+t}).join(",")+",b)}"),a.push("proto.step=function "+n+"_step("+u.join(",")+"){var "+o.map(function(t){return"a"+t+"=this.shape["+t+"]"}).join(",")+","+o.map(function(t){return"b"+t+"=this.stride["+t+"]"}).join(",")+",c=this.offset,d=0,ceil=Math.ceil");for(v=0;v=0){c=(c+this.stride["+v+"]*i"+v+")|0}else{a.push(this.shape["+v+"]);b.push(this.stride["+v+"])}");return a.push("var ctor=CTOR_LIST[a.length+1];return ctor(this.data,a,b,c)}"),a.push("return function construct_"+n+"(data,shape,stride,offset){return new "+n+"(data,"+o.map(function(t){return"shape["+t+"]"}).join(",")+","+o.map(function(t){return"stride["+t+"]"}).join(",")+",offset)}"),new Function("CTOR_LIST","ORDER",a.join("\n"))(l[t],s)}var l={float32:[],float64:[],int8:[],int16:[],int32:[],uint8:[],uint16:[],uint32:[],array:[],uint8_clamped:[],buffer:[],generic:[]};e.exports=function(t,e,n,r){if(void 0===t)return(0,l.array[0])([]);"number"==typeof t&&(t=[t]),void 0===e&&(e=[t.length]);var o=e.length;if(void 0===n){n=new Array(o);for(var s=o-1,c=1;s>=0;--s)n[s]=c,c*=e[s]}if(void 0===r)for(r=0,s=0;s>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)+1}},{}],86:[function(t,e,n){(function(n,r){"use strict";var i=t("util"),a=t("stream"),o=e.exports=function(){a.call(this),this._buffers=[],this._buffered=0,this._reads=[],this._paused=!1,this._encoding="utf8",this.writable=!0};i.inherits(o,a),o.prototype.read=function(t,e){this._reads.push({length:Math.abs(t),allowLess:t<0,func:e}),n.nextTick(function(){this._process(),this._paused&&this._reads.length>0&&(this._paused=!1,this.emit("drain"))}.bind(this))},o.prototype.write=function(t,e){return this.writable?(r.isBuffer(t)||(t=new r(t,e||this._encoding)),this._buffers.push(t),this._buffered+=t.length,this._process(),this._reads&&0==this._reads.length&&(this._paused=!0),this.writable&&!this._paused):(this.emit("error",new Error("Stream not writable")),!1)},o.prototype.end=function(t,e){t&&this.write(t,e),this.writable=!1,this._buffers&&(0==this._buffers.length?this._end():(this._buffers.push(null),this._process()))},o.prototype.destroySoon=o.prototype.end,o.prototype._end=function(){this._reads.length>0&&this.emit("error",new Error("There are some read requests waitng on finished stream")),this.destroy()},o.prototype.destroy=function(){this._buffers&&(this.writable=!1,this._reads=null,this._buffers=null,this.emit("close"))},o.prototype._process=function(){for(;this._buffered>0&&this._reads&&this._reads.length>0;){var t=this._reads[0];if(t.allowLess){this._reads.shift(),(a=this._buffers[0]).length>t.length?(this._buffered-=t.length,this._buffers[0]=a.slice(t.length),t.func.call(this,a.slice(0,t.length))):(this._buffered-=a.length,this._buffers.shift(),t.func.call(this,a))}else{if(!(this._buffered>=t.length))break;this._reads.shift();for(var e=0,n=0,i=new r(t.length);e0&&this._buffers.splice(0,n),this._buffered-=t.length,t.func.call(this,i)}}this._buffers&&this._buffers.length>0&&null==this._buffers[0]&&this._end()}}).call(this,t("_process"),t("buffer").Buffer)},{_process:117,buffer:5,stream:139,util:150}],87:[function(t,e,n){"use strict";e.exports={PNG_SIGNATURE:[137,80,78,71,13,10,26,10],TYPE_IHDR:1229472850,TYPE_IEND:1229278788,TYPE_IDAT:1229209940,TYPE_PLTE:1347179589,TYPE_tRNS:1951551059,TYPE_gAMA:1732332865,COLOR_PALETTE:1,COLOR_COLOR:2,COLOR_ALPHA:4}},{}],88:[function(t,e,n){"use strict";var r=t("util"),i=t("stream"),a=e.exports=function(){i.call(this),this._crc=-1,this.writable=!0};r.inherits(a,i),a.prototype.write=function(t){for(var e=0;e>>8;return!0},a.prototype.end=function(t){t&&this.write(t),this.emit("crc",this.crc32())},a.prototype.crc32=function(){return-1^this._crc},a.crc32=function(t){for(var e=-1,n=0;n>>8;return-1^e};for(var o=[],s=0;s<256;s++){for(var u=s,l=0;l<8;l++)1&u?u=3988292384^u>>>1:u>>>=1;o[s]=u}},{stream:139,util:150}],89:[function(t,e,n){(function(n){"use strict";var r=t("util"),i=(t("zlib"),t("./chunkstream")),a=e.exports=function(t,e,n,r,a){i.call(this),this._width=t,this._height=e,this._Bpp=n,this._data=r,this._options=a,this._line=0,"filterType"in a&&-1!=a.filterType?"number"==typeof a.filterType&&(a.filterType=[a.filterType]):a.filterType=[0,1,2,3,4],this._filters={0:this._filterNone.bind(this),1:this._filterSub.bind(this),2:this._filterUp.bind(this),3:this._filterAvg.bind(this),4:this._filterPaeth.bind(this)},this.read(this._width*n+1,this._reverseFilterLine.bind(this))};r.inherits(a,i);var o={1:{0:0,1:0,2:0,3:255},2:{0:0,1:0,2:0,3:1},3:{0:0,1:1,2:2,3:255},4:{0:0,1:1,2:2,3:3}};a.prototype._reverseFilterLine=function(t){var e=this._data,n=this._width<<2,r=this._line*n,i=t[0];if(0==i)for(var a=0;a0?e[u+c-4]:0;e[u+c]=255!=f?t[l+f]+h:255}else if(2==i)for(a=0;a0?e[u-n+c]:0;e[u+c]=255!=f?t[l+f]+p:255}else if(3==i)for(a=0;a0?e[u+c-4]:0,p=this._line>0?e[u-n+c]:0;var d=Math.floor((h+p)/2);e[u+c]=255!=f?t[l+f]+d:255}else if(4==i)for(a=0;a0?e[u+c-4]:0,p=this._line>0?e[u-n+c]:0;var v=a>0&&this._line>0?e[u-n+c-4]:0;d=s(h,p,v);e[u+c]=255!=f?t[l+f]+d:255}this._line++,this._line=4?t[e*r+o-4]:0,u=t[e*r+o]-s;n?n[e*i+1+o]=u:a+=Math.abs(u)}return a},a.prototype._filterUp=function(t,e,n){var r=this._width<<2,i=r+1,a=0;n&&(n[e*i]=2);for(var o=0;o0?t[(e-1)*r+o]:0,u=t[e*r+o]-s;n?n[e*i+1+o]=u:a+=Math.abs(u)}return a},a.prototype._filterAvg=function(t,e,n){var r=this._width<<2,i=r+1,a=0;n&&(n[e*i]=3);for(var o=0;o=4?t[e*r+o-4]:0,u=e>0?t[(e-1)*r+o]:0,l=t[e*r+o]-(s+u>>1);n?n[e*i+1+o]=l:a+=Math.abs(l)}return a},a.prototype._filterPaeth=function(t,e,n){var r=this._width<<2,i=r+1,a=0;n&&(n[e*i]=4);for(var o=0;o=4?t[e*r+o-4]:0,l=e>0?t[(e-1)*r+o]:0,c=o>=4&&e>0?t[(e-1)*r+o-4]:0,f=t[e*r+o]-s(u,l,c);n?n[e*i+1+o]=f:a+=Math.abs(f)}return a};var s=function(t,e,n){var r=t+e-n,i=Math.abs(r-t),a=Math.abs(r-e),o=Math.abs(r-n);return i<=a&&i<=o?t:a<=o?e:n}}).call(this,t("buffer").Buffer)},{"./chunkstream":86,buffer:5,util:150,zlib:46}],90:[function(t,e,n){(function(n){"use strict";var r=t("util"),i=t("stream"),a=t("zlib"),o=t("./filter"),s=t("./crc"),u=t("./constants"),l=e.exports=function(t){i.call(this),this._options=t,t.deflateChunkSize=t.deflateChunkSize||32768,t.deflateLevel=t.deflateLevel||9,t.deflateStrategy=t.deflateStrategy||3,this.readable=!0};r.inherits(l,i),l.prototype.pack=function(t,e,r){this.emit("data",new n(u.PNG_SIGNATURE)),this.emit("data",this._packIHDR(e,r));t=new o(e,r,4,t,this._options).filter();var i=a.createDeflate({chunkSize:this._options.deflateChunkSize,level:this._options.deflateLevel,strategy:this._options.deflateStrategy});i.on("error",this.emit.bind(this,"error")),i.on("data",function(t){this.emit("data",this._packIDAT(t))}.bind(this)),i.on("end",function(){this.emit("data",this._packIEND()),this.emit("end")}.bind(this)),i.end(t)},l.prototype._packChunk=function(t,e){var r=e?e.length:0,i=new n(r+12);return i.writeUInt32BE(r,0),i.writeUInt32BE(t,4),e&&e.copy(i,8),i.writeInt32BE(s.crc32(i.slice(4,i.length-4)),i.length-4),i},l.prototype._packIHDR=function(t,e){var r=new n(13);return r.writeUInt32BE(t,0),r.writeUInt32BE(e,4),r[8]=8,r[9]=6,r[10]=0,r[11]=0,r[12]=0,this._packChunk(u.TYPE_IHDR,r)},l.prototype._packIDAT=function(t){return this._packChunk(u.TYPE_IDAT,t)},l.prototype._packIEND=function(){return this._packChunk(u.TYPE_IEND,null)}}).call(this,t("buffer").Buffer)},{"./constants":87,"./crc":88,"./filter":89,buffer:5,stream:139,util:150,zlib:46}],91:[function(t,e,n){(function(n){"use strict";var r=t("util"),i=t("zlib"),a=t("./crc"),o=t("./chunkstream"),s=t("./constants"),u=t("./filter"),l=e.exports=function(t){o.call(this),this._options=t,t.checkCRC=!1!==t.checkCRC,this._hasIHDR=!1,this._hasIEND=!1,this._inflate=null,this._filter=null,this._crc=null,this._palette=[],this._colorType=0,this._chunks={},this._chunks[s.TYPE_IHDR]=this._handleIHDR.bind(this),this._chunks[s.TYPE_IEND]=this._handleIEND.bind(this),this._chunks[s.TYPE_IDAT]=this._handleIDAT.bind(this),this._chunks[s.TYPE_PLTE]=this._handlePLTE.bind(this),this._chunks[s.TYPE_tRNS]=this._handleTRNS.bind(this),this._chunks[s.TYPE_gAMA]=this._handleGAMA.bind(this),this.writable=!0,this.on("error",this._handleError.bind(this)),this._handleSignature()};r.inherits(l,o),l.prototype._handleError=function(){this.writable=!1,this.destroy(),this._inflate&&this._inflate.destroy()},l.prototype._handleSignature=function(){this.read(s.PNG_SIGNATURE.length,this._parseSignature.bind(this))},l.prototype._parseSignature=function(t){for(var e=s.PNG_SIGNATURE,n=0;nthis._palette.length)return void this.emit("error",new Error("More transparent colors than palette size"));for(var e=0;e0?this._handleIDAT(t):this._handleChunkEnd()},l.prototype._handleIEND=function(t){this.read(t,this._parseIEND.bind(this))},l.prototype._parseIEND=function(t){this._crc.write(t),this._inflate.end(),this._hasIEND=!0,this._handleChunkEnd()};var c={0:1,2:3,3:1,4:2,6:4};l.prototype._reverseFiltered=function(t,e,n){if(3==this._colorType)for(var r=e<<2,i=0;i0&&this.height>0?new r(4*this.width*this.height):null,t.fill&&this.data&&this.data.fill(0),this.gamma=0,this.readable=this.writable=!0,this._parser=new o(t||{}),this._parser.on("error",this.emit.bind(this,"error")),this._parser.on("close",this._handleClose.bind(this)),this._parser.on("metadata",this._metadata.bind(this)),this._parser.on("gamma",this._gamma.bind(this)),this._parser.on("parsed",function(t){this.data=t,this.emit("parsed",t)}.bind(this)),this._packer=new s(t),this._packer.on("data",this.emit.bind(this,"data")),this._packer.on("end",this.emit.bind(this,"end")),this._parser.on("close",this._handleClose.bind(this)),this._packer.on("error",this.emit.bind(this,"error"))};i.inherits(u,a),u.prototype.pack=function(){return e.nextTick(function(){this._packer.pack(this.data,this.width,this.height)}.bind(this)),this},u.prototype.parse=function(t,e){if(e){var n,r=null;this.once("parsed",n=function(t){this.removeListener("error",r),this.data=t,e(null,this)}.bind(this)),this.once("error",r=function(t){this.removeListener("parsed",n),e(t,null)}.bind(this))}return this.end(t),this},u.prototype.write=function(t){return this._parser.write(t),!0},u.prototype.end=function(t){this._parser.end(t)},u.prototype._metadata=function(t){this.width=t.width,this.height=t.height,this.data=t.data,delete t.data,this.emit("metadata",t)},u.prototype._gamma=function(t){this.gamma=t},u.prototype._handleClose=function(){this._parser.writable||this._packer.readable||this.emit("close")},u.prototype.bitblt=function(t,e,n,r,i,a,o){if(e>this.width||n>this.height||e+r>this.width||n+i>this.height)throw new Error("bitblt reading outside image");if(a>t.width||o>t.height||a+r>t.width||o+i>t.height)throw new Error("bitblt writing outside image");for(var s=0;s>=u,c-=u,g!==a){if(g===o)break;for(var m=ga;)y=d[y]>>8,++_;var w=y;if(h+_+(m!==g?1:0)>r)return void console.log("Warning, gif stream longer than expected.");n[h++]=w;var b=h+=_;for(m!==g&&(n[h++]=w),y=m;_--;)y=d[y],n[--b]=255&y,y>>=8;null!==v&&s<4096&&(d[s++]=v<<8|w,s>=l+1&&u<12&&(++u,l=l<<1|1)),v=g}else s=o+1,l=(1<<(u=i+1))-1,v=null}return h!==r&&console.log("Warning, gif stream shorter than expected."),n}try{n.GifWriter=function(t,e,n,r){var i=0,a=void 0===(r=void 0===r?{}:r).loop?null:r.loop,o=void 0===r.palette?null:r.palette;if(e<=0||n<=0||e>65535||n>65535)throw new Error("Width/Height invalid.");function s(t){var e=t.length;if(e<2||e>256||e&e-1)throw new Error("Invalid code/color length, must be power of 2 and 2 .. 256.");return e}t[i++]=71,t[i++]=73,t[i++]=70,t[i++]=56,t[i++]=57,t[i++]=97;var u=0,l=0;if(null!==o){for(var c=s(o);c>>=1;)++u;if(c=1<=c)throw new Error("Background index out of range.");if(0===l)throw new Error("Background index explicitly passed as 0.")}}if(t[i++]=255&e,t[i++]=e>>8&255,t[i++]=255&n,t[i++]=n>>8&255,t[i++]=(null!==o?128:0)|u,t[i++]=l,t[i++]=0,null!==o)for(var f=0,h=o.length;f>16&255,t[i++]=p>>8&255,t[i++]=255&p}if(null!==a){if(a<0||a>65535)throw new Error("Loop count invalid.");t[i++]=33,t[i++]=255,t[i++]=11,t[i++]=78,t[i++]=69,t[i++]=84,t[i++]=83,t[i++]=67,t[i++]=65,t[i++]=80,t[i++]=69,t[i++]=50,t[i++]=46,t[i++]=48,t[i++]=3,t[i++]=1,t[i++]=255&a,t[i++]=a>>8&255,t[i++]=0}var d=!1;this.addFrame=function(e,n,r,a,u,l){if(!0===d&&(--i,d=!1),l=void 0===l?{}:l,e<0||n<0||e>65535||n>65535)throw new Error("x/y invalid.");if(r<=0||a<=0||r>65535||a>65535)throw new Error("Width/Height invalid.");if(u.length>=1;)++p;h=1<3)throw new Error("Disposal out of range.");var m=!1,_=0;if(void 0!==l.transparent&&null!==l.transparent&&(m=!0,(_=l.transparent)<0||_>=h))throw new Error("Transparent color index.");if((0!==g||m||0!==v)&&(t[i++]=33,t[i++]=249,t[i++]=4,t[i++]=g<<2|(!0===m?1:0),t[i++]=255&v,t[i++]=v>>8&255,t[i++]=_,t[i++]=0),t[i++]=44,t[i++]=255&e,t[i++]=e>>8&255,t[i++]=255&n,t[i++]=n>>8&255,t[i++]=255&r,t[i++]=r>>8&255,t[i++]=255&a,t[i++]=a>>8&255,t[i++]=!0===c?128|p-1:0,!0===c)for(var y=0,w=f.length;y>16&255,t[i++]=b>>8&255,t[i++]=255&b}return i=function(t,e,n,r){t[e++]=n;var i=e++,a=1<=n;)t[e++]=255&f,f>>=8,c-=8,e===i+256&&(t[i]=255,i=e++)}function p(t){f|=t<=8;)t[e++]=255&f,f>>=8,c-=8,e===i+256&&(t[i]=255,i=e++);4096===u?(p(a),u=s+1,l=n+1,v={}):(u>=1<>7,s=1<<1+(7&a);t[e++],t[e++];var u=null,l=null;o&&(u=e,l=s,e+=3*s);var c=!0,f=[],h=0,p=null,d=0,v=null;for(this.width=n,this.height=i;c&&e=0))throw Error("Invalid block size");if(0===A)break;e+=A}break;case 249:if(4!==t[e++]||0!==t[e+4])throw new Error("Invalid graphics extension block.");var g=t[e++];h=t[e++]|t[e++]<<8,p=t[e++],0==(1&g)&&(p=null),d=g>>2&7,e++;break;case 254:for(;;){if(!((A=t[e++])>=0))throw Error("Invalid block size");if(0===A)break;e+=A}break;default:throw new Error("Unknown graphic control label: 0x"+t[e-1].toString(16))}break;case 44:var m=t[e++]|t[e++]<<8,_=t[e++]|t[e++]<<8,y=t[e++]|t[e++]<<8,w=t[e++]|t[e++]<<8,b=t[e++],x=b>>6&1,k=1<<1+(7&b),E=u,S=l,j=!1;b>>7&&(j=!0,E=e,S=k,e+=3*k);var T=e;for(e++;;){var A;if(!((A=t[e++])>=0))throw Error("Invalid block size");if(0===A)break;e+=A}f.push({x:m,y:_,width:y,height:w,has_local_palette:j,palette_offset:E,palette_size:S,data_offset:T,data_length:e-T,transparent_index:p,interlaced:!!x,delay:h,disposal:d});break;case 59:c=!1;break;default:throw new Error("Unknown gif block: 0x"+t[e-1].toString(16))}this.numFrames=function(){return f.length},this.loopCount=function(){return v},this.frameInfo=function(t){if(t<0||t>=f.length)throw new Error("Frame index out of range.");return f[t]},this.decodeAndBlitFrameBGRA=function(e,i){var a=this.frameInfo(e),o=a.width*a.height,s=new Uint8Array(o);r(t,a.data_offset,s,o);var u=a.palette_offset,l=a.transparent_index;null===l&&(l=256);var c=a.width,f=n-c,h=c,p=4*(a.y*n+a.x),d=4*((a.y+a.height)*n+a.x),v=p,g=4*f;!0===a.interlaced&&(g+=4*n*7);for(var m=8,_=0,y=s.length;_=d&&(g=4*f+4*n*(m-1),v=p+(c+f)*(m<<1),m>>=1)),w===l)v+=4;else{var b=t[u+3*w],x=t[u+3*w+1],k=t[u+3*w+2];i[v++]=k,i[v++]=x,i[v++]=b,i[v++]=255}--h}},this.decodeAndBlitFrameRGBA=function(e,i){var a=this.frameInfo(e),o=a.width*a.height,s=new Uint8Array(o);r(t,a.data_offset,s,o);var u=a.palette_offset,l=a.transparent_index;null===l&&(l=256);var c=a.width,f=n-c,h=c,p=4*(a.y*n+a.x),d=4*((a.y+a.height)*n+a.x),v=p,g=4*f;!0===a.interlaced&&(g+=4*n*7);for(var m=8,_=0,y=s.length;_=d&&(g=4*f+4*n*(m-1),v=p+(c+f)*(m<<1),m>>=1)),w===l)v+=4;else{var b=t[u+3*w],x=t[u+3*w+1],k=t[u+3*w+2];i[v++]=b,i[v++]=x,i[v++]=k,i[v++]=255}--h}}}}catch(t){}},{}],94:[function(t,e,n){(function(n){var r=t("charm");function i(t){if(!(t=t||{}).total)throw new Error("You MUST specify the total number of operations that will be processed.");this.total=t.total,this.current=0,this.max_burden=t.maxBurden||.5,this.show_burden=t.showBurden||!1,this.started=!1,this.size=50,this.inner_time=0,this.outer_time=0,this.elapsed=0,this.time_start=0,this.time_end=0,this.time_left=0,this.time_burden=0,this.skip_steps=0,this.skipped=0,this.aborted=!1,this.charm=r(),this.charm.pipe(n.stdout),this.charm.write("\n\n\n")}function a(t,e,n){for(n=n||" ";t.length3&&(u[0]=u[0].replace(/\B(?=(?:\d{3})+(?!\d))/g,o)),(u[1]||"").length=this.total&&this.finished(),this.time_end=(new Date).getTime(),this.inner_time=this.time_end-this.time_start)},i.prototype.updateTimes=function(){this.elapsed=this.time_start-this.started,this.time_end>0&&(this.outer_time=this.time_start-this.time_end),this.inner_time>0&&this.outer_time>0&&(this.time_burden=this.inner_time/(this.inner_time+this.outer_time)*100,this.time_left=this.elapsed/this.current*(this.total-this.current),this.time_left<0&&(this.time_left=0)),this.time_burden>this.max_burden&&this.skip_steps0&&this.current=0;r--){var i=t[r];"."===i?t.splice(r,1):".."===i?(t.splice(r,1),n++):n&&(t.splice(r,1),n--)}if(e)for(;n--;n)t.unshift("..");return t}function r(t,e){if(t.filter)return t.filter(e);for(var n=[],r=0;r=-1&&!i;a--){var o=a>=0?arguments[a]:t.cwd();if("string"!=typeof o)throw new TypeError("Arguments to path.resolve must be strings");o&&(n=o+"/"+n,i="/"===o.charAt(0))}return n=e(r(n.split("/"),function(t){return!!t}),!i).join("/"),(i?"/":"")+n||"."},n.normalize=function(t){var a=n.isAbsolute(t),o="/"===i(t,-1);return(t=e(r(t.split("/"),function(t){return!!t}),!a).join("/"))||a||(t="."),t&&o&&(t+="/"),(a?"/":"")+t},n.isAbsolute=function(t){return"/"===t.charAt(0)},n.join=function(){var t=Array.prototype.slice.call(arguments,0);return n.normalize(r(t,function(t,e){if("string"!=typeof t)throw new TypeError("Arguments to path.join must be strings");return t}).join("/"))},n.relative=function(t,e){function r(t){for(var e=0;e=0&&""===t[n];n--);return e>n?[]:t.slice(e,n-e+1)}t=n.resolve(t).substr(1),e=n.resolve(e).substr(1);for(var i=r(t.split("/")),a=r(e.split("/")),o=Math.min(i.length,a.length),s=o,u=0;u=1;--a)if(47===(e=t.charCodeAt(a))){if(!i){r=a;break}}else i=!1;return-1===r?n?"/":".":n&&1===r?"/":t.slice(0,r)},n.basename=function(t,e){var n=function(t){"string"!=typeof t&&(t+="");var e,n=0,r=-1,i=!0;for(e=t.length-1;e>=0;--e)if(47===t.charCodeAt(e)){if(!i){n=e+1;break}}else-1===r&&(i=!1,r=e+1);return-1===r?"":t.slice(n,r)}(t);return e&&n.substr(-1*e.length)===e&&(n=n.substr(0,n.length-e.length)),n},n.extname=function(t){"string"!=typeof t&&(t+="");for(var e=-1,n=0,r=-1,i=!0,a=0,o=t.length-1;o>=0;--o){var s=t.charCodeAt(o);if(47!==s)-1===r&&(i=!1,r=o+1),46===s?-1===e?e=o:1!==a&&(a=1):-1!==e&&(a=-1);else if(!i){n=o+1;break}}return-1===e||-1===r||0===a||1===a&&e===r-1&&e===n+1?"":t.slice(e,r)};var i="b"==="ab".substr(-1)?function(t,e,n){return t.substr(e,n)}:function(t,e,n){return e<0&&(e=t.length+e),t.substr(e,n)}}).call(this,t("_process"))},{_process:117}],96:[function(t,e,n){(function(e){"use strict";var r=t("./interlace"),i={1:{0:0,1:0,2:0,3:255},2:{0:0,1:0,2:0,3:1},3:{0:0,1:1,2:2,3:255},4:{0:0,1:1,2:2,3:3}};function a(t,e,n,r,a,o){for(var s=t.width,u=t.height,l=t.index,c=0;c>4,n.push(f,c);break;case 2:u=3&h,l=h>>2&3,c=h>>4&3,f=h>>6&3,n.push(f,c,l,u);break;case 1:i=1&h,a=h>>1&1,o=h>>2&1,s=h>>3&1,u=h>>4&1,l=h>>5&1,c=h>>6&1,f=h>>7&1,n.push(f,c,l,u,s,o,a,i)}}return{get:function(t){for(;n.length0&&(this._paused=!1,this.emit("drain"))}.bind(this))},o.prototype.write=function(t,e){return this.writable?(n=r.isBuffer(t)?t:new r(t,e||this._encoding),this._buffers.push(n),this._buffered+=n.length,this._process(),this._reads&&0===this._reads.length&&(this._paused=!0),this.writable&&!this._paused):(this.emit("error",new Error("Stream not writable")),!1);var n},o.prototype.end=function(t,e){t&&this.write(t,e),this.writable=!1,this._buffers&&(0===this._buffers.length?this._end():(this._buffers.push(null),this._process()))},o.prototype.destroySoon=o.prototype.end,o.prototype._end=function(){this._reads.length>0&&this.emit("error",new Error("There are some read requests waitng on finished stream")),this.destroy()},o.prototype.destroy=function(){this._buffers&&(this.writable=!1,this._reads=null,this._buffers=null,this.emit("close"))},o.prototype._processReadAllowingLess=function(t){this._reads.shift();var e=this._buffers[0];e.length>t.length?(this._buffered-=t.length,this._buffers[0]=e.slice(t.length),t.func.call(this,e.slice(0,t.length))):(this._buffered-=e.length,this._buffers.shift(),t.func.call(this,e))},o.prototype._processRead=function(t){this._reads.shift();for(var e=0,n=0,i=new r(t.length);e0&&this._buffers.splice(0,n),this._buffered-=t.length,t.func.call(this,i)},o.prototype._process=function(){try{for(;this._buffered>0&&this._reads&&this._reads.length>0;){var t=this._reads[0];if(t.allowLess)this._processReadAllowingLess(t);else{if(!(this._buffered>=t.length))break;this._processRead(t)}}this._buffers&&this._buffers.length>0&&null===this._buffers[0]&&this._end()}catch(t){this.emit("error",t)}}}).call(this,t("_process"),t("buffer").Buffer)},{_process:117,buffer:5,stream:139,util:150}],99:[function(t,e,n){"use strict";e.exports={PNG_SIGNATURE:[137,80,78,71,13,10,26,10],TYPE_IHDR:1229472850,TYPE_IEND:1229278788,TYPE_IDAT:1229209940,TYPE_PLTE:1347179589,TYPE_tRNS:1951551059,TYPE_gAMA:1732332865,COLORTYPE_GRAYSCALE:0,COLORTYPE_PALETTE:1,COLORTYPE_COLOR:2,COLORTYPE_ALPHA:4,COLORTYPE_PALETTE_COLOR:3,COLORTYPE_COLOR_ALPHA:6,COLORTYPE_TO_BPP_MAP:{0:1,2:3,3:1,4:2,6:4},GAMMA_DIVISION:1e5}},{}],100:[function(t,e,n){"use strict";var r=[];!function(){for(var t=0;t<256;t++){for(var e=t,n=0;n<8;n++)1&e?e=3988292384^e>>>1:e>>>=1;r[t]=e}}();var i=e.exports=function(){this._crc=-1};i.prototype.write=function(t){for(var e=0;e>>8;return!0},i.prototype.crc32=function(){return-1^this._crc},i.crc32=function(t){for(var e=-1,n=0;n>>8;return-1^e}},{}],101:[function(t,e,n){(function(n){"use strict";var r=t("./paeth-predictor");var i={0:function(t,e,n,r,i){t.copy(r,i,e,e+n)},1:function(t,e,n,r,i,a){for(var o=0;o=a?t[e+o-a]:0,u=t[e+o]-s;r[i+o]=u}},2:function(t,e,n,r,i){for(var a=0;a0?t[e+a-n]:0,s=t[e+a]-o;r[i+a]=s}},3:function(t,e,n,r,i,a){for(var o=0;o=a?t[e+o-a]:0,u=e>0?t[e+o-n]:0,l=t[e+o]-(s+u>>1);r[i+o]=l}},4:function(t,e,n,i,a,o){for(var s=0;s=o?t[e+s-o]:0,l=e>0?t[e+s-n]:0,c=e>0&&s>=o?t[e+s-(n+o)]:0,f=t[e+s]-r(u,l,c);i[a+s]=f}}},a={0:function(t,e,n){for(var r=0,i=e+n,a=e;a=r?t[e+a-r]:0,s=t[e+a]-o;i+=Math.abs(s)}return i},2:function(t,e,n){for(var r=0,i=e+n,a=e;a0?t[a-n]:0,s=t[a]-o;r+=Math.abs(s)}return r},3:function(t,e,n,r){for(var i=0,a=0;a=r?t[e+a-r]:0,s=e>0?t[e+a-n]:0,u=t[e+a]-(o+s>>1);i+=Math.abs(u)}return i},4:function(t,e,n,i){for(var a=0,o=0;o=i?t[e+o-i]:0,u=e>0?t[e+o-n]:0,l=e>0&&o>=i?t[e+o-(n+i)]:0,c=t[e+o]-r(s,u,l);a+=Math.abs(c)}return a}};e.exports=function(t,e,r,o,s){var u;if("filterType"in o&&-1!==o.filterType){if("number"!=typeof o.filterType)throw new Error("unrecognised filter types");u=[o.filterType]}else u=[0,1,2,3,4];for(var l=e*s,c=0,f=0,h=new n((l+1)*r),p=u[0],d=0;d1)for(var v=1/0,g=0;gi?e[a-r]:0;e[a]=o+s}},o.prototype._unFilterType2=function(t,e,n){for(var r=this._lastLine,i=0;ii?e[o-r]:0,c=Math.floor((l+u)/2);e[o]=s+c}},o.prototype._unFilterType4=function(t,e,n){for(var r=this._xComparison,a=r-1,o=this._lastLine,s=0;sa?e[s-r]:0,f=s>a&&o?o[s-r]:0,h=i(c,l,f);e[s]=u+h}},o.prototype._reverseFilterLine=function(t){var e,r=t[0],i=this._images[this._imageIndex],a=i.byteWidth;if(0===r)e=t.slice(1,a+1);else switch(e=new n(a),r){case 1:this._unFilterType1(t,e,a);break;case 2:this._unFilterType2(t,e,a);break;case 3:this._unFilterType3(t,e,a);break;case 4:this._unFilterType4(t,e,a);break;default:throw new Error("Unrecognised filter type - "+r)}this.write(e),i.lineIndex++,i.lineIndex>=i.height?(this._lastLine=null,this._imageIndex++,i=this._images[this._imageIndex]):this._lastLine=e,i?this.read(i.byteWidth+1,this._reverseFilterLine.bind(this)):(this._lastLine=null,this.complete())}}).call(this,t("buffer").Buffer)},{"./interlace":106,"./paeth-predictor":110,buffer:5}],105:[function(t,e,n){(function(t){"use strict";e.exports=function(e,n){var r=n.depth,i=n.width,a=n.height,o=n.colorType,s=n.transColor,u=n.palette,l=e;return 3===o?function(t,e,n,r,i){for(var a=0,o=0;o0&&f>0&&n.push({width:c,height:f,index:u})}return n},n.getInterlaceIterator=function(t){return function(e,n,i){var a=e%r[i].x.length,o=(e-a)/r[i].x.length*8+r[i].x[a],s=n%r[i].y.length;return 4*o+((n-s)/r[i].y.length*8+r[i].y[s])*t*4}}},{}],107:[function(t,e,n){(function(n){"use strict";var r=t("util"),i=t("stream"),a=t("./constants"),o=t("./packer"),s=e.exports=function(t){i.call(this);var e=t||{};this._packer=new o(e),this._deflate=this._packer.createDeflate(),this.readable=!0};r.inherits(s,i),s.prototype.pack=function(t,e,r,i){this.emit("data",new n(a.PNG_SIGNATURE)),this.emit("data",this._packer.packIHDR(e,r)),i&&this.emit("data",this._packer.packGAMA(i));var o=this._packer.filterData(t,e,r);this._deflate.on("error",this.emit.bind(this,"error")),this._deflate.on("data",function(t){this.emit("data",this._packer.packIDAT(t))}.bind(this)),this._deflate.on("end",function(){this.emit("data",this._packer.packIEND()),this.emit("end")}.bind(this)),this._deflate.end(o)}}).call(this,t("buffer").Buffer)},{"./constants":99,"./packer":109,buffer:5,stream:139,util:150}],108:[function(t,e,n){(function(n){"use strict";var r=!0,i=t("zlib");i.deflateSync||(r=!1);var a=t("./constants"),o=t("./packer");e.exports=function(t,e){if(!r)throw new Error("To use the sync capability of this library in old node versions, please also add a dependency on node-zlb-backport");var s=new o(e||{}),u=[];u.push(new n(a.PNG_SIGNATURE)),u.push(s.packIHDR(t.width,t.height)),t.gamma&&u.push(s.packGAMA(t.gamma));var l=s.filterData(t.data,t.width,t.height),c=i.deflateSync(l,s.getDeflateOptions());if(l=null,!c||!c.length)throw new Error("bad png - invalid compressed data response");return u.push(s.packIDAT(c)),u.push(s.packIEND()),n.concat(u)}}).call(this,t("buffer").Buffer)},{"./constants":99,"./packer":109,buffer:5,zlib:46}],109:[function(t,e,n){(function(n){"use strict";var r=t("./constants"),i=t("./crc"),a=t("./bitpacker"),o=t("./filter-pack"),s=t("zlib"),u=e.exports=function(t){if(this._options=t,t.deflateChunkSize=t.deflateChunkSize||32768,t.deflateLevel=null!=t.deflateLevel?t.deflateLevel:9,t.deflateStrategy=null!=t.deflateStrategy?t.deflateStrategy:3,t.inputHasAlpha=null==t.inputHasAlpha||t.inputHasAlpha,t.deflateFactory=t.deflateFactory||s.createDeflate,t.bitDepth=t.bitDepth||8,t.colorType="number"==typeof t.colorType?t.colorType:r.COLORTYPE_COLOR_ALPHA,t.colorType!==r.COLORTYPE_COLOR&&t.colorType!==r.COLORTYPE_COLOR_ALPHA)throw new Error("option color type:"+t.colorType+" is not supported at present");if(8!==t.bitDepth)throw new Error("option bit depth:"+t.bitDepth+" is not supported at present")};u.prototype.getDeflateOptions=function(){return{chunkSize:this._options.deflateChunkSize,level:this._options.deflateLevel,strategy:this._options.deflateStrategy}},u.prototype.createDeflate=function(){return this._options.deflateFactory(this.getDeflateOptions())},u.prototype.filterData=function(t,e,n){var i=a(t,e,n,this._options),s=r.COLORTYPE_TO_BPP_MAP[this._options.colorType];return o(i,e,n,this._options,s)},u.prototype._packChunk=function(t,e){var r=e?e.length:0,a=new n(r+12);return a.writeUInt32BE(r,0),a.writeUInt32BE(t,4),e&&e.copy(a,8),a.writeInt32BE(i.crc32(a.slice(4,a.length-4)),a.length-4),a},u.prototype.packGAMA=function(t){var e=new n(4);return e.writeUInt32BE(Math.floor(t*r.GAMMA_DIVISION),0),this._packChunk(r.TYPE_gAMA,e)},u.prototype.packIHDR=function(t,e){var i=new n(13);return i.writeUInt32BE(t,0),i.writeUInt32BE(e,4),i[8]=this._options.bitDepth,i[9]=this._options.colorType,i[10]=0,i[11]=0,i[12]=0,this._packChunk(r.TYPE_IHDR,i)},u.prototype.packIDAT=function(t){return this._packChunk(r.TYPE_IDAT,t)},u.prototype.packIEND=function(){return this._packChunk(r.TYPE_IEND,null)}}).call(this,t("buffer").Buffer)},{"./bitpacker":97,"./constants":99,"./crc":100,"./filter-pack":101,buffer:5,zlib:46}],110:[function(t,e,n){"use strict";e.exports=function(t,e,n){var r=t+e-n,i=Math.abs(r-t),a=Math.abs(r-e),o=Math.abs(r-n);return i<=a&&i<=o?t:a<=o?e:n}},{}],111:[function(t,e,n){"use strict";var r=t("util"),i=t("zlib"),a=t("./chunkstream"),o=t("./filter-parse-async"),s=t("./parser"),u=t("./bitmapper"),l=t("./format-normaliser"),c=e.exports=function(t){a.call(this),this._parser=new s(t,{read:this.read.bind(this),error:this._handleError.bind(this),metadata:this._handleMetaData.bind(this),gamma:this.emit.bind(this,"gamma"),palette:this._handlePalette.bind(this),transColor:this._handleTransColor.bind(this),finished:this._finished.bind(this),inflateData:this._inflateData.bind(this)}),this._options=t,this.writable=!0,this._parser.start()};r.inherits(c,a),c.prototype._handleError=function(t){this.emit("error",t),this.writable=!1,this.destroy(),this._inflate&&this._inflate.destroy&&this._inflate.destroy(),this.errord=!0},c.prototype._inflateData=function(t){this._inflate||(this._inflate=i.createInflate(),this._inflate.on("error",this.emit.bind(this,"error")),this._filter.on("complete",this._complete.bind(this)),this._inflate.pipe(this._filter)),this._inflate.write(t)},c.prototype._handleMetaData=function(t){this.emit("metadata",t),this._bitmapInfo=Object.create(t),this._filter=new o(this._bitmapInfo)},c.prototype._handleTransColor=function(t){this._bitmapInfo.transColor=t},c.prototype._handlePalette=function(t){this._bitmapInfo.palette=t},c.prototype._finished=function(){this.errord||(this._inflate?this._inflate.end():this.emit("error","No Inflate block"),this.destroySoon())},c.prototype._complete=function(t){if(!this.errord){try{var e=u.dataToBitMap(t,this._bitmapInfo),n=l(e,this._bitmapInfo);e=null}catch(t){return void this._handleError(t)}this.emit("parsed",n)}}},{"./bitmapper":96,"./chunkstream":98,"./filter-parse-async":102,"./format-normaliser":105,"./parser":113,util:150,zlib:46}],112:[function(t,e,n){(function(n){"use strict";var r=!0,i=t("zlib");i.deflateSync||(r=!1);var a=t("./sync-reader"),o=t("./filter-parse-sync"),s=t("./parser"),u=t("./bitmapper"),l=t("./format-normaliser");e.exports=function(t,e){if(!r)throw new Error("To use the sync capability of this library in old node versions, please also add a dependency on node-zlb-backport");var c,f,h;var p=[];var d=new a(t);if(new s(e,{read:d.read.bind(d),error:function(t){c=t},metadata:function(t){f=t},gamma:function(t){h=t},palette:function(t){f.palette=t},transColor:function(t){f.transColor=t},inflateData:function(t){p.push(t)}}).start(),d.process(),c)throw c;var v=n.concat(p);p.length=0;var g=i.inflateSync(v);if(v=null,!g||!g.length)throw new Error("bad png - invalid inflate data response");var m=o.process(g,f);v=null;var _=u.dataToBitMap(m,f);m=null;var y=l(_,f);return f.data=y,f.gamma=h||0,f}}).call(this,t("buffer").Buffer)},{"./bitmapper":96,"./filter-parse-sync":103,"./format-normaliser":105,"./parser":113,"./sync-reader":116,buffer:5,zlib:46}],113:[function(t,e,n){(function(n){"use strict";var r=t("./constants"),i=t("./crc"),a=e.exports=function(t,e){this._options=t,t.checkCRC=!1!==t.checkCRC,this._hasIHDR=!1,this._hasIEND=!1,this._palette=[],this._colorType=0,this._chunks={},this._chunks[r.TYPE_IHDR]=this._handleIHDR.bind(this),this._chunks[r.TYPE_IEND]=this._handleIEND.bind(this),this._chunks[r.TYPE_IDAT]=this._handleIDAT.bind(this),this._chunks[r.TYPE_PLTE]=this._handlePLTE.bind(this),this._chunks[r.TYPE_tRNS]=this._handleTRNS.bind(this),this._chunks[r.TYPE_gAMA]=this._handleGAMA.bind(this),this.read=e.read,this.error=e.error,this.metadata=e.metadata,this.gamma=e.gamma,this.transColor=e.transColor,this.palette=e.palette,this.parsed=e.parsed,this.inflateData=e.inflateData,this.inflateData=e.inflateData,this.finished=e.finished};a.prototype.start=function(){this.read(r.PNG_SIGNATURE.length,this._parseSignature.bind(this))},a.prototype._parseSignature=function(t){for(var e=r.PNG_SIGNATURE,n=0;nthis._palette.length)return void this.error(new Error("More transparent colors than palette size"));for(var e=0;e0?this._handleIDAT(n):this._handleChunkEnd()},a.prototype._handleIEND=function(t){this.read(t,this._parseIEND.bind(this))},a.prototype._parseIEND=function(t){this._crc.write(t),this._hasIEND=!0,this._handleChunkEnd(),this.finished&&this.finished()}}).call(this,t("buffer").Buffer)},{"./constants":99,"./crc":100,buffer:5}],114:[function(t,e,n){"use strict";var r=t("./parser-sync"),i=t("./packer-sync");n.read=function(t,e){return r(t,e||{})},n.write=function(t){return i(t)}},{"./packer-sync":108,"./parser-sync":112}],115:[function(t,e,n){(function(e,r){"use strict";var i=t("util"),a=t("stream"),o=t("./parser-async"),s=t("./packer-async"),u=t("./png-sync"),l=n.PNG=function(t){a.call(this),t=t||{},this.width=t.width||0,this.height=t.height||0,this.data=this.width>0&&this.height>0?new r(4*this.width*this.height):null,t.fill&&this.data&&this.data.fill(0),this.gamma=0,this.readable=this.writable=!0,this._parser=new o(t),this._parser.on("error",this.emit.bind(this,"error")),this._parser.on("close",this._handleClose.bind(this)),this._parser.on("metadata",this._metadata.bind(this)),this._parser.on("gamma",this._gamma.bind(this)),this._parser.on("parsed",function(t){this.data=t,this.emit("parsed",t)}.bind(this)),this._packer=new s(t),this._packer.on("data",this.emit.bind(this,"data")),this._packer.on("end",this.emit.bind(this,"end")),this._parser.on("close",this._handleClose.bind(this)),this._packer.on("error",this.emit.bind(this,"error"))};i.inherits(l,a),l.sync=u,l.prototype.pack=function(){return this.data&&this.data.length?(e.nextTick(function(){this._packer.pack(this.data,this.width,this.height,this.gamma)}.bind(this)),this):(this.emit("error","No data provided"),this)},l.prototype.parse=function(t,e){var n,r;e&&(n=function(t){this.removeListener("error",r),this.data=t,e(null,this)}.bind(this),r=function(t){this.removeListener("parsed",n),e(t,null)}.bind(this),this.once("parsed",n),this.once("error",r));return this.end(t),this},l.prototype.write=function(t){return this._parser.write(t),!0},l.prototype.end=function(t){this._parser.end(t)},l.prototype._metadata=function(t){this.width=t.width,this.height=t.height,this.emit("metadata",t)},l.prototype._gamma=function(t){this.gamma=t},l.prototype._handleClose=function(){this._parser.writable||this._packer.readable||this.emit("close")},l.bitblt=function(t,e,n,r,i,a,o,s){if(n>t.width||r>t.height||n+i>t.width||r+a>t.height)throw new Error("bitblt reading outside image");if(o>e.width||s>e.height||o+i>e.width||s+a>e.height)throw new Error("bitblt writing outside image");for(var u=0;u0&&this._buffer.length;){var t=this._reads[0];if(!this._buffer.length||!(this._buffer.length>=t.length||t.allowLess))break;this._reads.shift();var e=this._buffer;this._buffer=e.slice(t.length),t.func.call(this,e.slice(0,t.length))}return this._reads.length>0?new Error("There are some read requests waitng on finished stream"):this._buffer.length>0?new Error("unrecognised content at end of stream"):void 0}},{}],117:[function(t,e,n){var r,i,a=e.exports={};function o(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function u(t){if(r===setTimeout)return setTimeout(t,0);if((r===o||!r)&&setTimeout)return r=setTimeout,setTimeout(t,0);try{return r(t,0)}catch(e){try{return r.call(null,t,0)}catch(e){return r.call(this,t,0)}}}!function(){try{r="function"==typeof setTimeout?setTimeout:o}catch(t){r=o}try{i="function"==typeof clearTimeout?clearTimeout:s}catch(t){i=s}}();var l,c=[],f=!1,h=-1;function p(){f&&l&&(f=!1,l.length?c=l.concat(c):h=-1,c.length&&d())}function d(){if(!f){var t=u(p);f=!0;for(var e=c.length;e;){for(l=c,c=[];++h1)for(var n=1;n0?("string"==typeof e||o.objectMode||Object.getPrototypeOf(e)===l.prototype||(e=function(t){return l.from(t)}(e)),r?o.endEmitted?t.emit("error",new Error("stream.unshift() after end event")):b(t,o,e,!0):o.ended?t.emit("error",new Error("stream.push() after EOF")):(o.reading=!1,o.decoder&&!n?(e=o.decoder.write(e),o.objectMode||0!==e.length?b(t,o,e,!1):j(t,o)):b(t,o,e,!1))):r||(o.reading=!1));return function(t){return!t.ended&&(t.needReadable||t.lengthe.highWaterMark&&(e.highWaterMark=function(t){return t>=x?t=x:(t--,t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,t|=t>>>16,t++),t}(t)),t<=e.length?t:e.ended?e.length:(e.needReadable=!0,0))}function E(t){var e=t._readableState;e.needReadable=!1,e.emittedReadable||(p("emitReadable",e.flowing),e.emittedReadable=!0,e.sync?i.nextTick(S,t):S(t))}function S(t){p("emit readable"),t.emit("readable"),M(t)}function j(t,e){e.readingMore||(e.readingMore=!0,i.nextTick(T,t,e))}function T(t,e){for(var n=e.length;!e.reading&&!e.flowing&&!e.ended&&e.length=e.length?(n=e.decoder?e.buffer.join(""):1===e.buffer.length?e.buffer.head.data:e.buffer.concat(e.length),e.buffer.clear()):n=function(t,e,n){var r;ta.length?a.length:t;if(o===a.length?i+=a:i+=a.slice(0,t),0===(t-=o)){o===a.length?(++r,n.next?e.head=n.next:e.head=e.tail=null):(e.head=n,n.data=a.slice(o));break}++r}return e.length-=r,i}(t,e):function(t,e){var n=l.allocUnsafe(t),r=e.head,i=1;r.data.copy(n),t-=r.data.length;for(;r=r.next;){var a=r.data,o=t>a.length?a.length:t;if(a.copy(n,n.length-t,0,o),0===(t-=o)){o===a.length?(++i,r.next?e.head=r.next:e.head=e.tail=null):(e.head=r,r.data=a.slice(o));break}++i}return e.length-=i,n}(t,e);return r}(t,e.buffer,e.decoder),n);var n}function R(t){var e=t._readableState;if(e.length>0)throw new Error('"endReadable()" called on non-empty stream');e.endEmitted||(e.ended=!0,i.nextTick(L,e,t))}function L(t,e){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}function B(t,e){for(var n=0,r=t.length;n=e.highWaterMark||e.ended))return p("read: emitReadable",e.length,e.ended),0===e.length&&e.ended?R(this):E(this),null;if(0===(t=k(t,e))&&e.ended)return 0===e.length&&R(this),null;var r,i=e.needReadable;return p("need readable",i),(0===e.length||e.length-t0?I(t,e):null)?(e.needReadable=!0,t=0):e.length-=t,0===e.length&&(e.ended||(e.needReadable=!0),n!==t&&e.ended&&R(this)),null!==r&&this.emit("data",r),r},y.prototype._read=function(t){this.emit("error",new Error("_read() is not implemented"))},y.prototype.pipe=function(t,e){var r=this,a=this._readableState;switch(a.pipesCount){case 0:a.pipes=t;break;case 1:a.pipes=[a.pipes,t];break;default:a.pipes.push(t)}a.pipesCount+=1,p("pipe count=%d opts=%j",a.pipesCount,e);var u=(!e||!1!==e.end)&&t!==n.stdout&&t!==n.stderr?c:y;function l(e,n){p("onunpipe"),e===r&&n&&!1===n.hasUnpiped&&(n.hasUnpiped=!0,p("cleanup"),t.removeListener("close",m),t.removeListener("finish",_),t.removeListener("drain",f),t.removeListener("error",g),t.removeListener("unpipe",l),r.removeListener("end",c),r.removeListener("end",y),r.removeListener("data",v),h=!0,!a.awaitDrain||t._writableState&&!t._writableState.needDrain||f())}function c(){p("onend"),t.end()}a.endEmitted?i.nextTick(u):r.once("end",u),t.on("unpipe",l);var f=function(t){return function(){var e=t._readableState;p("pipeOnDrain",e.awaitDrain),e.awaitDrain&&e.awaitDrain--,0===e.awaitDrain&&s(t,"data")&&(e.flowing=!0,M(t))}}(r);t.on("drain",f);var h=!1;var d=!1;function v(e){p("ondata"),d=!1,!1!==t.write(e)||d||((1===a.pipesCount&&a.pipes===t||a.pipesCount>1&&-1!==B(a.pipes,t))&&!h&&(p("false write response, pause",r._readableState.awaitDrain),r._readableState.awaitDrain++,d=!0),r.pause())}function g(e){p("onerror",e),y(),t.removeListener("error",g),0===s(t,"error")&&t.emit("error",e)}function m(){t.removeListener("finish",_),y()}function _(){p("onfinish"),t.removeListener("close",m),y()}function y(){p("unpipe"),r.unpipe(t)}return r.on("data",v),function(t,e,n){if("function"==typeof t.prependListener)return t.prependListener(e,n);t._events&&t._events[e]?o(t._events[e])?t._events[e].unshift(n):t._events[e]=[n,t._events[e]]:t.on(e,n)}(t,"error",g),t.once("close",m),t.once("finish",_),t.emit("pipe",r),a.flowing||(p("pipe resume"),r.resume()),t},y.prototype.unpipe=function(t){var e=this._readableState,n={hasUnpiped:!1};if(0===e.pipesCount)return this;if(1===e.pipesCount)return t&&t!==e.pipes?this:(t||(t=e.pipes),e.pipes=null,e.pipesCount=0,e.flowing=!1,t&&t.emit("unpipe",this,n),this);if(!t){var r=e.pipes,i=e.pipesCount;e.pipes=null,e.pipesCount=0,e.flowing=!1;for(var a=0;a-1?i:a.nextTick;_.WritableState=m;var l=t("core-util-is");l.inherits=t("inherits");var c={deprecate:t("util-deprecate")},f=t("./internal/streams/stream"),h=t("safe-buffer").Buffer,p=r.Uint8Array||function(){};var d,v=t("./internal/streams/destroy");function g(){}function m(e,n){s=s||t("./_stream_duplex"),e=e||{};var r=n instanceof s;this.objectMode=!!e.objectMode,r&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var i=e.highWaterMark,l=e.writableHighWaterMark,c=this.objectMode?16:16384;this.highWaterMark=i||0===i?i:r&&(l||0===l)?l:c,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var f=!1===e.decodeStrings;this.decodeStrings=!f,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(t){!function(t,e){var n=t._writableState,r=n.sync,i=n.writecb;if(function(t){t.writing=!1,t.writecb=null,t.length-=t.writelen,t.writelen=0}(n),e)!function(t,e,n,r,i){--e.pendingcb,n?(a.nextTick(i,r),a.nextTick(E,t,e),t._writableState.errorEmitted=!0,t.emit("error",r)):(i(r),t._writableState.errorEmitted=!0,t.emit("error",r),E(t,e))}(t,n,r,e,i);else{var o=x(n);o||n.corked||n.bufferProcessing||!n.bufferedRequest||b(t,n),r?u(w,t,n,o,i):w(t,n,o,i)}}(n,t)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new o(this)}function _(e){if(s=s||t("./_stream_duplex"),!(d.call(_,this)||this instanceof s))return new _(e);this._writableState=new m(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),f.call(this)}function y(t,e,n,r,i,a,o){e.writelen=r,e.writecb=o,e.writing=!0,e.sync=!0,n?t._writev(i,e.onwrite):t._write(i,a,e.onwrite),e.sync=!1}function w(t,e,n,r){n||function(t,e){0===e.length&&e.needDrain&&(e.needDrain=!1,t.emit("drain"))}(t,e),e.pendingcb--,r(),E(t,e)}function b(t,e){e.bufferProcessing=!0;var n=e.bufferedRequest;if(t._writev&&n&&n.next){var r=e.bufferedRequestCount,i=new Array(r),a=e.corkedRequestsFree;a.entry=n;for(var s=0,u=!0;n;)i[s]=n,n.isBuf||(u=!1),n=n.next,s+=1;i.allBuffers=u,y(t,e,!0,e.length,i,"",a.finish),e.pendingcb++,e.lastBufferedRequest=null,a.next?(e.corkedRequestsFree=a.next,a.next=null):e.corkedRequestsFree=new o(e),e.bufferedRequestCount=0}else{for(;n;){var l=n.chunk,c=n.encoding,f=n.callback;if(y(t,e,!1,e.objectMode?1:l.length,l,c,f),n=n.next,e.bufferedRequestCount--,e.writing)break}null===n&&(e.lastBufferedRequest=null)}e.bufferedRequest=n,e.bufferProcessing=!1}function x(t){return t.ending&&0===t.length&&null===t.bufferedRequest&&!t.finished&&!t.writing}function k(t,e){t._final(function(n){e.pendingcb--,n&&t.emit("error",n),e.prefinished=!0,t.emit("prefinish"),E(t,e)})}function E(t,e){var n=x(e);return n&&(!function(t,e){e.prefinished||e.finalCalled||("function"==typeof t._final?(e.pendingcb++,e.finalCalled=!0,a.nextTick(k,t,e)):(e.prefinished=!0,t.emit("prefinish")))}(t,e),0===e.pendingcb&&(e.finished=!0,t.emit("finish"))),n}l.inherits(_,f),m.prototype.getBuffer=function(){for(var t=this.bufferedRequest,e=[];t;)e.push(t),t=t.next;return e},function(){try{Object.defineProperty(m.prototype,"buffer",{get:c.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(t){}}(),"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(d=Function.prototype[Symbol.hasInstance],Object.defineProperty(_,Symbol.hasInstance,{value:function(t){return!!d.call(this,t)||this===_&&(t&&t._writableState instanceof m)}})):d=function(t){return t instanceof this},_.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},_.prototype.write=function(t,e,n){var r,i=this._writableState,o=!1,s=!i.objectMode&&(r=t,h.isBuffer(r)||r instanceof p);return s&&!h.isBuffer(t)&&(t=function(t){return h.from(t)}(t)),"function"==typeof e&&(n=e,e=null),s?e="buffer":e||(e=i.defaultEncoding),"function"!=typeof n&&(n=g),i.ended?function(t,e){var n=new Error("write after end");t.emit("error",n),a.nextTick(e,n)}(this,n):(s||function(t,e,n,r){var i=!0,o=!1;return null===n?o=new TypeError("May not write null values to stream"):"string"==typeof n||void 0===n||e.objectMode||(o=new TypeError("Invalid non-string/buffer chunk")),o&&(t.emit("error",o),a.nextTick(r,o),i=!1),i}(this,i,t,n))&&(i.pendingcb++,o=function(t,e,n,r,i,a){if(!n){var o=function(t,e,n){t.objectMode||!1===t.decodeStrings||"string"!=typeof e||(e=h.from(e,n));return e}(e,r,i);r!==o&&(n=!0,i="buffer",r=o)}var s=e.objectMode?1:r.length;e.length+=s;var u=e.length-1))throw new TypeError("Unknown encoding: "+t);return this._writableState.defaultEncoding=t,this},Object.defineProperty(_.prototype,"writableHighWaterMark",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),_.prototype._write=function(t,e,n){n(new Error("_write() is not implemented"))},_.prototype._writev=null,_.prototype.end=function(t,e,n){var r=this._writableState;"function"==typeof t?(n=t,t=null,e=null):"function"==typeof e&&(n=e,e=null),null!==t&&void 0!==t&&this.write(t,e),r.corked&&(r.corked=1,this.uncork()),r.ending||r.finished||function(t,e,n){e.ending=!0,E(t,e),n&&(e.finished?a.nextTick(n):t.once("finish",n));e.ended=!0,t.writable=!1}(this,r,n)},Object.defineProperty(_.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(t){this._writableState&&(this._writableState.destroyed=t)}}),_.prototype.destroy=v.destroy,_.prototype._undestroy=v.undestroy,_.prototype._destroy=function(t,e){this.end(),e(t)}}).call(this,t("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},t("timers").setImmediate)},{"./_stream_duplex":119,"./internal/streams/destroy":125,"./internal/streams/stream":126,_process:117,"core-util-is":15,inherits:70,"process-nextick-args":128,"safe-buffer":134,timers:142,"util-deprecate":148}],124:[function(t,e,n){"use strict";var r=t("safe-buffer").Buffer,i=t("util");e.exports=function(){function t(){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),this.head=null,this.tail=null,this.length=0}return t.prototype.push=function(t){var e={data:t,next:null};this.length>0?this.tail.next=e:this.head=e,this.tail=e,++this.length},t.prototype.unshift=function(t){var e={data:t,next:this.head};0===this.length&&(this.tail=e),this.head=e,++this.length},t.prototype.shift=function(){if(0!==this.length){var t=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,t}},t.prototype.clear=function(){this.head=this.tail=null,this.length=0},t.prototype.join=function(t){if(0===this.length)return"";for(var e=this.head,n=""+e.data;e=e.next;)n+=t+e.data;return n},t.prototype.concat=function(t){if(0===this.length)return r.alloc(0);if(1===this.length)return this.head.data;for(var e,n,i,a=r.allocUnsafe(t>>>0),o=this.head,s=0;o;)e=o.data,n=a,i=s,e.copy(n,i),s+=o.data.length,o=o.next;return a},t}(),i&&i.inspect&&i.inspect.custom&&(e.exports.prototype[i.inspect.custom]=function(){var t=i.inspect({length:this.length});return this.constructor.name+" "+t})},{"safe-buffer":134,util:4}],125:[function(t,e,n){"use strict";var r=t("process-nextick-args");function i(t,e){t.emit("error",e)}e.exports={destroy:function(t,e){var n=this,a=this._readableState&&this._readableState.destroyed,o=this._writableState&&this._writableState.destroyed;return a||o?(e?e(t):!t||this._writableState&&this._writableState.errorEmitted||r.nextTick(i,this,t),this):(this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(t||null,function(t){!e&&t?(r.nextTick(i,n,t),n._writableState&&(n._writableState.errorEmitted=!0)):e&&e(t)}),this)},undestroy:function(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}}},{"process-nextick-args":128}],126:[function(t,e,n){e.exports=t("events").EventEmitter},{events:48}],127:[function(t,e,n){var r={}.toString;e.exports=Array.isArray||function(t){return"[object Array]"==r.call(t)}},{}],128:[function(t,e,n){(function(t){"use strict";!t.version||0===t.version.indexOf("v0.")||0===t.version.indexOf("v1.")&&0!==t.version.indexOf("v1.8.")?e.exports={nextTick:function(e,n,r,i){if("function"!=typeof e)throw new TypeError('"callback" argument must be a function');var a,o,s=arguments.length;switch(s){case 0:case 1:return t.nextTick(e);case 2:return t.nextTick(function(){e.call(null,n)});case 3:return t.nextTick(function(){e.call(null,n,r)});case 4:return t.nextTick(function(){e.call(null,n,r,i)});default:for(a=new Array(s-1),o=0;o>5==6?2:t>>4==14?3:t>>3==30?4:t>>6==2?-1:-2}function s(t){var e=this.lastTotal-this.lastNeed,n=function(t,e,n){if(128!=(192&e[0]))return t.lastNeed=0,"�";if(t.lastNeed>1&&e.length>1){if(128!=(192&e[1]))return t.lastNeed=1,"�";if(t.lastNeed>2&&e.length>2&&128!=(192&e[2]))return t.lastNeed=2,"�"}}(this,t);return void 0!==n?n:this.lastNeed<=t.length?(t.copy(this.lastChar,e,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(t.copy(this.lastChar,e,0,t.length),void(this.lastNeed-=t.length))}function u(t,e){if((t.length-e)%2==0){var n=t.toString("utf16le",e);if(n){var r=n.charCodeAt(n.length-1);if(r>=55296&&r<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=t[t.length-2],this.lastChar[1]=t[t.length-1],n.slice(0,-1)}return n}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=t[t.length-1],t.toString("utf16le",e,t.length-1)}function l(t){var e=t&&t.length?this.write(t):"";if(this.lastNeed){var n=this.lastTotal-this.lastNeed;return e+this.lastChar.toString("utf16le",0,n)}return e}function c(t,e){var n=(t.length-e)%3;return 0===n?t.toString("base64",e):(this.lastNeed=3-n,this.lastTotal=3,1===n?this.lastChar[0]=t[t.length-1]:(this.lastChar[0]=t[t.length-2],this.lastChar[1]=t[t.length-1]),t.toString("base64",e,t.length-n))}function f(t){var e=t&&t.length?this.write(t):"";return this.lastNeed?e+this.lastChar.toString("base64",0,3-this.lastNeed):e}function h(t){return t.toString(this.encoding)}function p(t){return t&&t.length?this.write(t):""}n.StringDecoder=a,a.prototype.write=function(t){if(0===t.length)return"";var e,n;if(this.lastNeed){if(void 0===(e=this.fillLast(t)))return"";n=this.lastNeed,this.lastNeed=0}else n=0;return n=0)return i>0&&(t.lastNeed=i-1),i;if(--r=0)return i>0&&(t.lastNeed=i-2),i;if(--r=0)return i>0&&(2===i?i=0:t.lastNeed=i-3),i;return 0}(this,t,e);if(!this.lastNeed)return t.toString("utf8",e);this.lastTotal=n;var r=t.length-(n-this.lastNeed);return t.copy(this.lastChar,0,r),t.toString("utf8",e,r)},a.prototype.fillLast=function(t){if(this.lastNeed<=t.length)return t.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);t.copy(this.lastChar,this.lastTotal-this.lastNeed,0,t.length),this.lastNeed-=t.length}},{"safe-buffer":134}],130:[function(t,e,n){e.exports=t("./readable").PassThrough},{"./readable":131}],131:[function(t,e,n){(n=e.exports=t("./lib/_stream_readable.js")).Stream=n,n.Readable=n,n.Writable=t("./lib/_stream_writable.js"),n.Duplex=t("./lib/_stream_duplex.js"),n.Transform=t("./lib/_stream_transform.js"),n.PassThrough=t("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":119,"./lib/_stream_passthrough.js":120,"./lib/_stream_readable.js":121,"./lib/_stream_transform.js":122,"./lib/_stream_writable.js":123}],132:[function(t,e,n){e.exports=t("./readable").Transform},{"./readable":131}],133:[function(t,e,n){e.exports=t("./lib/_stream_writable.js")},{"./lib/_stream_writable.js":123}],134:[function(t,e,n){var r=t("buffer"),i=r.Buffer;function a(t,e){for(var n in t)e[n]=t[n]}function o(t,e,n){return i(t,e,n)}i.from&&i.alloc&&i.allocUnsafe&&i.allocUnsafeSlow?e.exports=r:(a(r,n),n.Buffer=o),a(i,o),o.from=function(t,e,n){if("number"==typeof t)throw new TypeError("Argument must not be a number");return i(t,e,n)},o.alloc=function(t,e,n){if("number"!=typeof t)throw new TypeError("Argument must be a number");var r=i(t);return void 0!==e?"string"==typeof n?r.fill(e,n):r.fill(e):r.fill(0),r},o.allocUnsafe=function(t){if("number"!=typeof t)throw new TypeError("Argument must be a number");return i(t)},o.allocUnsafeSlow=function(t){if("number"!=typeof t)throw new TypeError("Argument must be a number");return r.SlowBuffer(t)}},{buffer:5}],135:[function(t,e,n){arguments[4][67][0].apply(n,arguments)},{"./lib/decoder":136,"./lib/encoder":137,dup:67}],136:[function(t,e,n){(function(t){var n=function(){"use strict";var t=new Int32Array([0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63]),e=4017,n=799,r=3406,i=2276,a=1567,o=3784,s=5793,u=2896;function l(){}function c(t,e){for(var n,r,i=0,a=[],o=16;o>0&&!t[o-1];)o--;a.push({children:[],index:0});var s,u=a[0];for(n=0;n0;)u=a.pop();for(u.index++,a.push(u);a.length<=n;)a.push(s={children:[],index:0}),u.children[u.index]=s.children,u=s;i++}n+10)return p>>--d&1;if(255==(p=e[n++])){var t=e[n++];if(t)throw"unexpected marker: "+(p<<8|t).toString(16)}return d=7,p>>>7}function g(t){for(var e,n=t;null!==(e=v());){if("number"==typeof(n=n[e]))return n;if("object"!=typeof n)throw"invalid huffman sequence"}return null}function m(t){for(var e=0;t>0;){var n=v();if(null===n)return;e=e<<1|n,t--}return e}function _(t){var e=m(t);return e>=1<0)y--;else for(var r=o,i=s;r<=i;){var a=g(e.huffmanTableAC),u=15&a,c=a>>4;if(0!==u)n[t[r+=c]]=_(u)*(1<>4,0===f)a<15?(y=m(a)+(1<>4;if(0!==s)n[t[a+=u]]=_(s),a++;else{if(u<15)break;a+=16}}};var I,R,L,B,F=0;for(R=1==M?i[0].blocksPerLine*i[0].blocksPerColumn:c*r.mcusPerColumn,a||(a=R);F=65488&&I<=65495))break;n+=2}return n-h}function h(t,l){var c,f,h=[],p=l.blocksPerLine,d=l.blocksPerColumn,v=p<<3,g=new Int32Array(64),m=new Uint8Array(64);function _(t,c,f){var h,p,d,v,g,m,_,y,w,b,x=l.quantizationTable,k=f;for(b=0;b<64;b++)k[b]=t[b]*x[b];for(b=0;b<8;++b){var E=8*b;0!=k[1+E]||0!=k[2+E]||0!=k[3+E]||0!=k[4+E]||0!=k[5+E]||0!=k[6+E]||0!=k[7+E]?(h=s*k[0+E]+128>>8,p=s*k[4+E]+128>>8,d=k[2+E],v=k[6+E],g=u*(k[1+E]-k[7+E])+128>>8,y=u*(k[1+E]+k[7+E])+128>>8,m=k[3+E]<<4,_=k[5+E]<<4,w=h-p+1>>1,h=h+p+1>>1,p=w,w=d*o+v*a+128>>8,d=d*a-v*o+128>>8,v=w,w=g-_+1>>1,g=g+_+1>>1,_=w,w=y+m+1>>1,m=y-m+1>>1,y=w,w=h-v+1>>1,h=h+v+1>>1,v=w,w=p-d+1>>1,p=p+d+1>>1,d=w,w=g*i+y*r+2048>>12,g=g*r-y*i+2048>>12,y=w,w=m*n+_*e+2048>>12,m=m*e-_*n+2048>>12,_=w,k[0+E]=h+y,k[7+E]=h-y,k[1+E]=p+_,k[6+E]=p-_,k[2+E]=d+m,k[5+E]=d-m,k[3+E]=v+g,k[4+E]=v-g):(w=s*k[0+E]+512>>10,k[0+E]=w,k[1+E]=w,k[2+E]=w,k[3+E]=w,k[4+E]=w,k[5+E]=w,k[6+E]=w,k[7+E]=w)}for(b=0;b<8;++b){var S=b;0!=k[8+S]||0!=k[16+S]||0!=k[24+S]||0!=k[32+S]||0!=k[40+S]||0!=k[48+S]||0!=k[56+S]?(h=s*k[0+S]+2048>>12,p=s*k[32+S]+2048>>12,d=k[16+S],v=k[48+S],g=u*(k[8+S]-k[56+S])+2048>>12,y=u*(k[8+S]+k[56+S])+2048>>12,m=k[24+S],_=k[40+S],w=h-p+1>>1,h=h+p+1>>1,p=w,w=d*o+v*a+2048>>12,d=d*a-v*o+2048>>12,v=w,w=g-_+1>>1,g=g+_+1>>1,_=w,w=y+m+1>>1,m=y-m+1>>1,y=w,w=h-v+1>>1,h=h+v+1>>1,v=w,w=p-d+1>>1,p=p+d+1>>1,d=w,w=g*i+y*r+2048>>12,g=g*r-y*i+2048>>12,y=w,w=m*n+_*e+2048>>12,m=m*e-_*n+2048>>12,_=w,k[0+S]=h+y,k[56+S]=h-y,k[8+S]=p+_,k[48+S]=p-_,k[16+S]=d+m,k[40+S]=d-m,k[24+S]=v+g,k[32+S]=v-g):(w=s*f[b+0]+8192>>14,k[0+S]=w,k[8+S]=w,k[16+S]=w,k[24+S]=w,k[32+S]=w,k[40+S]=w,k[48+S]=w,k[56+S]=w)}for(b=0;b<64;++b){var j=128+(k[b]+8>>4);c[b]=j<0?0:j>255?255:j}}for(var y=0;y255?255:t}return l.prototype={load:function(t){var e=new XMLHttpRequest;e.open("GET",t,!0),e.responseType="arraybuffer",e.onload=function(){var t=new Uint8Array(e.response||e.mozResponseArrayBuffer);this.parse(t),this.onload&&this.onload()}.bind(this),e.send(null)},parse:function(e){var n=0;e.length;function r(){var t=e[n]<<8|e[n+1];return n+=2,t}function i(){var t=r(),i=e.subarray(n,n+t-2);return n+=i.length,i}function a(t){var e,n,r=0,i=0;for(n in t.components)t.components.hasOwnProperty(n)&&(r<(e=t.components[n]).h&&(r=e.h),i>4==0)for(_=0;_<64;_++){x[t[_]]=e[n++]}else{if(b>>4!=1)throw"DQT: invalid table spec";for(_=0;_<64;_++){x[t[_]]=r()}}p[15&b]=x}break;case 65472:case 65473:case 65474:r(),(o={}).extended=65473===m,o.progressive=65474===m,o.precision=e[n++],o.scanLines=r(),o.samplesPerLine=r(),o.components={},o.componentsOrder=[];var k,E=e[n++];for(U=0;U>4,j=15&e[n+1],T=e[n+2];o.componentsOrder.push(k),o.components[k]={h:S,v:j,quantizationTable:p[T]},n+=3}a(o),d.push(o);break;case 65476:var A=r();for(U=2;U>4==0?g:v)[15&C]=c(M,R)}break;case 65501:r(),s=r();break;case 65498:r();var L=e[n++],B=[];for(U=0;U>4],z.huffmanTableAC=v[15&F],B.push(z)}var P=e[n++],O=e[n++],D=e[n++],N=f(e,n,o,B,s,P,O,D>>4,15&D);n+=N;break;default:if(255==e[n-3]&&e[n-2]>=192&&e[n-2]<=254){n-=3;break}throw"unknown JPEG marker "+m.toString(16)}m=r()}if(1!=d.length)throw"only single frame JPEGs supported";this.width=o.samplesPerLine,this.height=o.scanLines,this.jfif=u,this.adobe=l,this.components=[];for(var U=0;U=this.charLength-this.charReceived?this.charLength-this.charReceived:t.length;if(t.copy(this.charBuffer,this.charReceived,0,n),this.charReceived+=n,this.charReceived=55296&&i<=56319)){if(this.charReceived=this.charLength=0,0===t.length)return e;break}this.charLength+=this.surrogateSize,e=""}this.detectIncompleteChar(t);var r=t.length;this.charLength&&(t.copy(this.charBuffer,0,t.length-this.charReceived,r),r-=this.charReceived);var i;r=(e+=t.toString(this.encoding,0,r)).length-1;if((i=e.charCodeAt(r))>=55296&&i<=56319){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),t.copy(this.charBuffer,0,0,a),e.substring(0,r)}return e},a.prototype.detectIncompleteChar=function(t){for(var e=t.length>=3?3:t.length;e>0;e--){var n=t[t.length-e];if(1==e&&n>>5==6){this.charLength=2;break}if(e<=2&&n>>4==14){this.charLength=3;break}if(e<=3&&n>>3==30){this.charLength=4;break}}this.charReceived=e},a.prototype.end=function(t){var e="";if(t&&t.length&&(e=this.write(t)),this.charReceived){var n=this.charReceived,r=this.charBuffer,i=this.encoding;e+=r.slice(0,n).toString(i)}return e}},{buffer:5}],141:[function(t,e,n){(function(n){var r=t("stream");function i(t,e,i){t=t||function(t){this.queue(t)},e=e||function(){this.queue(null)};var a=!1,o=!1,s=[],u=!1,l=new r;function c(){for(;s.length&&!l.paused;){var t=s.shift();if(null===t)return l.emit("end");l.emit("data",t)}}return l.readable=l.writable=!0,l.paused=!1,l.autoDestroy=!(i&&!1===i.autoDestroy),l.write=function(e){return t.call(this,e),!l.paused},l.queue=l.push=function(t){return u?l:(null===t&&(u=!0),s.push(t),c(),l)},l.on("end",function(){l.readable=!1,!l.writable&&l.autoDestroy&&n.nextTick(function(){l.destroy()})}),l.end=function(t){if(!a)return a=!0,arguments.length&&l.write(t),l.writable=!1,e.call(l),!l.readable&&l.autoDestroy&&l.destroy(),l},l.destroy=function(){if(!o)return o=!0,a=!0,s.length=0,l.writable=l.readable=!1,l.emit("close"),l},l.pause=function(){if(!l.paused)return l.paused=!0,l},l.resume=function(){return l.paused&&(l.paused=!1,l.emit("resume")),c(),l.paused||l.emit("drain"),l},l}e.exports=i,i.through=i}).call(this,t("_process"))},{_process:117,stream:139}],142:[function(t,e,n){(function(e,r){var i=t("process/browser.js").nextTick,a=Function.prototype.apply,o=Array.prototype.slice,s={},u=0;function l(t,e){this._id=t,this._clearFn=e}n.setTimeout=function(){return new l(a.call(setTimeout,window,arguments),clearTimeout)},n.setInterval=function(){return new l(a.call(setInterval,window,arguments),clearInterval)},n.clearTimeout=n.clearInterval=function(t){t.close()},l.prototype.unref=l.prototype.ref=function(){},l.prototype.close=function(){this._clearFn.call(window,this._id)},n.enroll=function(t,e){clearTimeout(t._idleTimeoutId),t._idleTimeout=e},n.unenroll=function(t){clearTimeout(t._idleTimeoutId),t._idleTimeout=-1},n._unrefActive=n.active=function(t){clearTimeout(t._idleTimeoutId);var e=t._idleTimeout;e>=0&&(t._idleTimeoutId=setTimeout(function(){t._onTimeout&&t._onTimeout()},e))},n.setImmediate="function"==typeof e?e:function(t){var e=u++,r=!(arguments.length<2)&&o.call(arguments,1);return s[e]=!0,i(function(){s[e]&&(r?t.apply(null,r):t.call(null),n.clearImmediate(e))}),e},n.clearImmediate="function"==typeof r?r:function(t){delete s[t]}}).call(this,t("timers").setImmediate,t("timers").clearImmediate)},{"process/browser.js":117,timers:142}],143:[function(t,e,n){n.isatty=function(){return!1},n.ReadStream=function(){throw new Error("tty.ReadStream is not implemented")},n.WriteStream=function(){throw new Error("tty.WriteStream is not implemented")}},{}],144:[function(t,e,n){(function(e,r){"use strict";var i=t("bit-twiddle"),a=t("dup");e.__TYPEDARRAY_POOL||(e.__TYPEDARRAY_POOL={UINT8:a([32,0]),UINT16:a([32,0]),UINT32:a([32,0]),INT8:a([32,0]),INT16:a([32,0]),INT32:a([32,0]),FLOAT:a([32,0]),DOUBLE:a([32,0]),DATA:a([32,0]),UINT8C:a([32,0]),BUFFER:a([32,0])});var o="undefined"!=typeof Uint8ClampedArray,s=e.__TYPEDARRAY_POOL;s.UINT8C||(s.UINT8C=a([32,0])),s.BUFFER||(s.BUFFER=a([32,0]));var u=s.DATA,l=s.BUFFER;function c(t){if(t){var e=t.length||t.byteLength,n=i.log2(e);u[n].push(t)}}function f(t){t=i.nextPow2(t);var e=i.log2(t),n=u[e];return n.length>0?n.pop():new ArrayBuffer(t)}function h(t){return new Uint8Array(f(t),0,t)}function p(t){return new Uint16Array(f(2*t),0,t)}function d(t){return new Uint32Array(f(4*t),0,t)}function v(t){return new Int8Array(f(t),0,t)}function g(t){return new Int16Array(f(2*t),0,t)}function m(t){return new Int32Array(f(4*t),0,t)}function _(t){return new Float32Array(f(4*t),0,t)}function y(t){return new Float64Array(f(8*t),0,t)}function w(t){return o?new Uint8ClampedArray(f(t),0,t):h(t)}function b(t){return new DataView(f(t),0,t)}function x(t){t=i.nextPow2(t);var e=i.log2(t),n=l[e];return n.length>0?n.pop():new r(t)}n.free=function(t){if(r.isBuffer(t))l[i.log2(t.length)].push(t);else{if("[object ArrayBuffer]"!==Object.prototype.toString.call(t)&&(t=t.buffer),!t)return;var e=t.length||t.byteLength,n=0|i.log2(e);u[n].push(t)}},n.freeUint8=n.freeUint16=n.freeUint32=n.freeInt8=n.freeInt16=n.freeInt32=n.freeFloat32=n.freeFloat=n.freeFloat64=n.freeDouble=n.freeUint8Clamped=n.freeDataView=function(t){c(t.buffer)},n.freeArrayBuffer=c,n.freeBuffer=function(t){l[i.log2(t.length)].push(t)},n.malloc=function(t,e){if(void 0===e||"arraybuffer"===e)return f(t);switch(e){case"uint8":return h(t);case"uint16":return p(t);case"uint32":return d(t);case"int8":return v(t);case"int16":return g(t);case"int32":return m(t);case"float":case"float32":return _(t);case"double":case"float64":return y(t);case"uint8_clamped":return w(t);case"buffer":return x(t);case"data":case"dataview":return b(t);default:return null}return null},n.mallocArrayBuffer=f,n.mallocUint8=h,n.mallocUint16=p,n.mallocUint32=d,n.mallocInt8=v,n.mallocInt16=g,n.mallocInt32=m,n.mallocFloat32=n.mallocFloat=_,n.mallocFloat64=n.mallocDouble=y,n.mallocUint8Clamped=w,n.mallocDataView=b,n.mallocBuffer=x,n.clearCache=function(){for(var t=0;t<32;++t)s.UINT8[t].length=0,s.UINT16[t].length=0,s.UINT32[t].length=0,s.INT8[t].length=0,s.INT16[t].length=0,s.INT32[t].length=0,s.FLOAT[t].length=0,s.DOUBLE[t].length=0,s.UINT8C[t].length=0,u[t].length=0,l[t].length=0}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},t("buffer").Buffer)},{"bit-twiddle":2,buffer:5,dup:21}],145:[function(t,e,n){(function(){var t=this,r=t._,i={},a=Array.prototype,o=Object.prototype,s=Function.prototype,u=a.push,l=a.slice,c=a.concat,f=o.toString,h=o.hasOwnProperty,p=a.forEach,d=a.map,v=a.reduce,g=a.reduceRight,m=a.filter,_=a.every,y=a.some,w=a.indexOf,b=a.lastIndexOf,x=Array.isArray,k=Object.keys,E=s.bind,S=function(t){return t instanceof S?t:this instanceof S?void(this._wrapped=t):new S(t)};void 0!==n?(void 0!==e&&e.exports&&(n=e.exports=S),n._=S):t._=S,S.VERSION="1.4.4";var j=S.each=S.forEach=function(t,e,n){if(null!=t)if(p&&t.forEach===p)t.forEach(e,n);else if(t.length===+t.length){for(var r=0,a=t.length;r2;if(null==t&&(t=[]),v&&t.reduce===v)return r&&(e=S.bind(e,r)),i?t.reduce(e,n):t.reduce(e);if(j(t,function(t,a,o){i?n=e.call(r,n,t,a,o):(n=t,i=!0)}),!i)throw new TypeError(T);return n},S.reduceRight=S.foldr=function(t,e,n,r){var i=arguments.length>2;if(null==t&&(t=[]),g&&t.reduceRight===g)return r&&(e=S.bind(e,r)),i?t.reduceRight(e,n):t.reduceRight(e);var a=t.length;if(a!==+a){var o=S.keys(t);a=o.length}if(j(t,function(s,u,l){u=o?o[--a]:--a,i?n=e.call(r,n,t[u],u,l):(n=t[u],i=!0)}),!i)throw new TypeError(T);return n},S.find=S.detect=function(t,e,n){var r;return A(t,function(t,i,a){if(e.call(n,t,i,a))return r=t,!0}),r},S.filter=S.select=function(t,e,n){var r=[];return null==t?r:m&&t.filter===m?t.filter(e,n):(j(t,function(t,i,a){e.call(n,t,i,a)&&(r[r.length]=t)}),r)},S.reject=function(t,e,n){return S.filter(t,function(t,r,i){return!e.call(n,t,r,i)},n)},S.every=S.all=function(t,e,n){e||(e=S.identity);var r=!0;return null==t?r:_&&t.every===_?t.every(e,n):(j(t,function(t,a,o){if(!(r=r&&e.call(n,t,a,o)))return i}),!!r)};var A=S.some=S.any=function(t,e,n){e||(e=S.identity);var r=!1;return null==t?r:y&&t.some===y?t.some(e,n):(j(t,function(t,a,o){if(r||(r=e.call(n,t,a,o)))return i}),!!r)};S.contains=S.include=function(t,e){return null!=t&&(w&&t.indexOf===w?-1!=t.indexOf(e):A(t,function(t){return t===e}))},S.invoke=function(t,e){var n=l.call(arguments,2),r=S.isFunction(e);return S.map(t,function(t){return(r?e:t[e]).apply(t,n)})},S.pluck=function(t,e){return S.map(t,function(t){return t[e]})},S.where=function(t,e,n){return S.isEmpty(e)?n?null:[]:S[n?"find":"filter"](t,function(t){for(var n in e)if(e[n]!==t[n])return!1;return!0})},S.findWhere=function(t,e){return S.where(t,e,!0)},S.max=function(t,e,n){if(!e&&S.isArray(t)&&t[0]===+t[0]&&t.length<65535)return Math.max.apply(Math,t);if(!e&&S.isEmpty(t))return-1/0;var r={computed:-1/0,value:-1/0};return j(t,function(t,i,a){var o=e?e.call(n,t,i,a):t;o>=r.computed&&(r={value:t,computed:o})}),r.value},S.min=function(t,e,n){if(!e&&S.isArray(t)&&t[0]===+t[0]&&t.length<65535)return Math.min.apply(Math,t);if(!e&&S.isEmpty(t))return 1/0;var r={computed:1/0,value:1/0};return j(t,function(t,i,a){var o=e?e.call(n,t,i,a):t;or||void 0===n)return 1;if(n>>1;n.call(r,t[s])=0})})},S.difference=function(t){var e=c.apply(a,l.call(arguments,1));return S.filter(t,function(t){return!S.contains(e,t)})},S.zip=function(){for(var t=l.call(arguments),e=S.max(S.pluck(t,"length")),n=new Array(e),r=0;r=0;n--)e=[t[n].apply(this,e)];return e[0]}},S.after=function(t,e){return t<=0?e():function(){if(--t<1)return e.apply(this,arguments)}},S.keys=k||function(t){if(t!==Object(t))throw new TypeError("Invalid object");var e=[];for(var n in t)S.has(t,n)&&(e[e.length]=n);return e},S.values=function(t){var e=[];for(var n in t)S.has(t,n)&&e.push(t[n]);return e},S.pairs=function(t){var e=[];for(var n in t)S.has(t,n)&&e.push([n,t[n]]);return e},S.invert=function(t){var e={};for(var n in t)S.has(t,n)&&(e[t[n]]=n);return e},S.functions=S.methods=function(t){var e=[];for(var n in t)S.isFunction(t[n])&&e.push(n);return e.sort()},S.extend=function(t){return j(l.call(arguments,1),function(e){if(e)for(var n in e)t[n]=e[n]}),t},S.pick=function(t){var e={},n=c.apply(a,l.call(arguments,1));return j(n,function(n){n in t&&(e[n]=t[n])}),e},S.omit=function(t){var e={},n=c.apply(a,l.call(arguments,1));for(var r in t)S.contains(n,r)||(e[r]=t[r]);return e},S.defaults=function(t){return j(l.call(arguments,1),function(e){if(e)for(var n in e)null==t[n]&&(t[n]=e[n])}),t},S.clone=function(t){return S.isObject(t)?S.isArray(t)?t.slice():S.extend({},t):t},S.tap=function(t,e){return e(t),t};var R=function(t,e,n,r){if(t===e)return 0!==t||1/t==1/e;if(null==t||null==e)return t===e;t instanceof S&&(t=t._wrapped),e instanceof S&&(e=e._wrapped);var i=f.call(t);if(i!=f.call(e))return!1;switch(i){case"[object String]":return t==String(e);case"[object Number]":return t!=+t?e!=+e:0==t?1/t==1/e:t==+e;case"[object Date]":case"[object Boolean]":return+t==+e;case"[object RegExp]":return t.source==e.source&&t.global==e.global&&t.multiline==e.multiline&&t.ignoreCase==e.ignoreCase}if("object"!=typeof t||"object"!=typeof e)return!1;for(var a=n.length;a--;)if(n[a]==t)return r[a]==e;n.push(t),r.push(e);var o=0,s=!0;if("[object Array]"==i){if(s=(o=t.length)==e.length)for(;o--&&(s=R(t[o],e[o],n,r)););}else{var u=t.constructor,l=e.constructor;if(u!==l&&!(S.isFunction(u)&&u instanceof u&&S.isFunction(l)&&l instanceof l))return!1;for(var c in t)if(S.has(t,c)&&(o++,!(s=S.has(e,c)&&R(t[c],e[c],n,r))))break;if(s){for(c in e)if(S.has(e,c)&&!o--)break;s=!o}}return n.pop(),r.pop(),s};S.isEqual=function(t,e){return R(t,e,[],[])},S.isEmpty=function(t){if(null==t)return!0;if(S.isArray(t)||S.isString(t))return 0===t.length;for(var e in t)if(S.has(t,e))return!1;return!0},S.isElement=function(t){return!(!t||1!==t.nodeType)},S.isArray=x||function(t){return"[object Array]"==f.call(t)},S.isObject=function(t){return t===Object(t)},j(["Arguments","Function","String","Number","Date","RegExp"],function(t){S["is"+t]=function(e){return f.call(e)=="[object "+t+"]"}}),S.isArguments(arguments)||(S.isArguments=function(t){return!(!t||!S.has(t,"callee"))}),"function"!=typeof/./&&(S.isFunction=function(t){return"function"==typeof t}),S.isFinite=function(t){return isFinite(t)&&!isNaN(parseFloat(t))},S.isNaN=function(t){return S.isNumber(t)&&t!=+t},S.isBoolean=function(t){return!0===t||!1===t||"[object Boolean]"==f.call(t)},S.isNull=function(t){return null===t},S.isUndefined=function(t){return void 0===t},S.has=function(t,e){return h.call(t,e)},S.noConflict=function(){return t._=r,this},S.identity=function(t){return t},S.times=function(t,e,n){for(var r=Array(t),i=0;i":">",'"':""","'":"'","/":"/"}};L.unescape=S.invert(L.escape);var B={escape:new RegExp("["+S.keys(L.escape).join("")+"]","g"),unescape:new RegExp("("+S.keys(L.unescape).join("|")+")","g")};S.each(["escape","unescape"],function(t){S[t]=function(e){return null==e?"":(""+e).replace(B[t],function(e){return L[t][e]})}}),S.result=function(t,e){if(null==t)return null;var n=t[e];return S.isFunction(n)?n.call(t):n},S.mixin=function(t){j(S.functions(t),function(e){var n=S[e]=t[e];S.prototype[e]=function(){var t=[this._wrapped];return u.apply(t,arguments),N.call(this,n.apply(S,t))}})};var F=0;S.uniqueId=function(t){var e=++F+"";return t?t+e:e},S.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var P=/(.)^/,O={"'":"'","\\":"\\","\r":"r","\n":"n","\t":"t","\u2028":"u2028","\u2029":"u2029"},D=/\\|'|\r|\n|\t|\u2028|\u2029/g;S.template=function(t,e,n){var r;n=S.defaults({},n,S.templateSettings);var i=new RegExp([(n.escape||P).source,(n.interpolate||P).source,(n.evaluate||P).source].join("|")+"|$","g"),a=0,o="__p+='";t.replace(i,function(e,n,r,i,s){return o+=t.slice(a,s).replace(D,function(t){return"\\"+O[t]}),n&&(o+="'+\n((__t=("+n+"))==null?'':_.escape(__t))+\n'"),r&&(o+="'+\n((__t=("+r+"))==null?'':__t)+\n'"),i&&(o+="';\n"+i+"\n__p+='"),a=s+e.length,e}),o+="';\n",n.variable||(o="with(obj||{}){\n"+o+"}\n"),o="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+o+"return __p;\n";try{r=new Function(n.variable||"obj","_",o)}catch(t){throw t.source=o,t}if(e)return r(e,S);var s=function(t){return r.call(this,t,S)};return s.source="function("+(n.variable||"obj")+"){\n"+o+"}",s},S.chain=function(t){return S(t).chain()};var N=function(t){return this._chain?S(t).chain():t};S.mixin(S),j(["pop","push","reverse","shift","sort","splice","unshift"],function(t){var e=a[t];S.prototype[t]=function(){var n=this._wrapped;return e.apply(n,arguments),"shift"!=t&&"splice"!=t||0!==n.length||delete n[0],N.call(this,n)}}),j(["concat","join","slice"],function(t){var e=a[t];S.prototype[t]=function(){return N.call(this,e.apply(this._wrapped,arguments))}}),S.extend(S.prototype,{chain:function(){return this._chain=!0,this},value:function(){return this._wrapped}})}).call(this)},{}],146:[function(t,e,n){"use strict";e.exports=function(t,e,n){return 0===t.length?t:e?(n||t.sort(e),function(t,e){for(var n=1,r=t.length,i=t[0],a=t[0],o=1;o=o?u+1:o}r.mkdir(e+"sequencer"+o,function(){var a=e+"sequencer"+o+"/";for(var s in n.images){var u=n.images[s].steps;if(i){var l=u.slice(-1)[0].output.src,c=u.slice(-1)[0].output.format,f=t("data-uri-to-buffer")(l);r.writeFile(a+s+"_"+(u.length-1)+"."+c,f,function(){})}else for(var h in u){l=u[h].output.src,c=u[h].output.format,f=t("data-uri-to-buffer")(l);r.writeFile(a+s+"_"+h+"."+c,f,function(){})}}})},r.readdir(c,function(t,e){var n=[];if(void 0===e||0==e.length)return f(n),[];for(var i=0;i0&&(thisStep=c[t].steps[e],thisStep.UI.onRemove(thisStep.options.step),c[t].steps.splice(e,1))}function v(){var e=[],n=this;for(var r in arguments)e.push(a(arguments[r]));var i=l.call(this,e,"l");f.push({method:"loadImages",json_q:a(i)});var o=this.copy(i.loadedimages),s={name:"ImageSequencer Wrapper",sequencer:this,addSteps:this.addSteps,removeSteps:this.removeSteps,insertSteps:this.insertSteps,run:this.run,UI:this.UI,setUI:this.setUI,images:o};!function e(r){if(r!=o.length){var a=o[r];t("./ui/LoadImage")(n,a,i.images[a],function(){e(++r)})}else i.callback.call(s)}(0)}function g(t){var e={};if("load-image"==t)return{};if(0==arguments.length){for(var n in this.modules)e[n]=s[n][1];for(var r in this.sequences)e[r]={name:r,steps:u[r]}}else e=s[t]?s[t][1]:{inputs:u[t].options};return e}function m(t){let e=a(g(t.options.name).inputs);e=e||{};for(let n in e)e[n]=t.options[n]||e[n].default,e[n]=encodeURIComponent(e[n]);var n=Object.keys(e).map(t=>t+":"+e[t]).join("|");return`${t.options.name}{${n}}`}function _(t){let e;return(e=t.includes(",")?t.split(","):[t]).map(y)}function y(t){var e;if(e=t.includes("{")?t.includes("(")&&t.indexOf("(")=e.images[u].steps.length?{options:{name:void 0}}:e.images[u].steps.slice(f+t)[0]},e.images[u].steps[f].getIndex=function(){return f},r)r.hasOwnProperty(p)&&(e.images[u].steps[f][p]=r[p]);e.images[u].steps[f].UI.onDraw(e.images[u].steps[f].options.step);var d=t("./RunToolkit")(e.copy(h));e.images[u].steps[f].draw(d,function(){e.images[u].steps[f].options.step.output=e.images[u].steps[f].output.src,e.images[u].steps[f].UI.onComplete(e.images[u].steps[f].options.step),n(a,++s)},o)}}(s,a)}(n=function(t){for(var n in t)0==t[n]&&1==e.images[n].steps.length?delete t[n]:0==t[n]&&t[n]++;for(var n in t)for(var r=e.images[n].steps[t[n]-1];void 0===r||void 0===r.output;)r=e.images[n].steps[--t[n]-1];return t}(n))}},{"./RunToolkit":159,"./util/getStep.js":240}],159:[function(t,e,n){const r=t("get-pixels"),i=t("./modules/_nomodule/PixelManipulation"),a=t("lodash"),o=t("data-uri-to-buffer"),s=t("save-pixels");e.exports=function(t){return t.getPixels=r,t.pixelManipulation=i,t.lodash=a,t.dataUriToBuffer=o,t.savePixels=s,t}},{"./modules/_nomodule/PixelManipulation":235,"data-uri-to-buffer":20,"get-pixels":30,lodash:75,"save-pixels":138}],160:[function(t,e,n){e.exports={sample:[{name:"invert",options:{}},{name:"channel",options:{channel:"red"}},{name:"blur",options:{blur:"5"}}]}},{}],161:[function(t,e,n){e.exports=function(e,n){return e.blur=e.blur||2,e.step.metadata=e.step.metadata||{},{options:e,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return t("../_nomodule/PixelManipulation.js")(n,{output:function(t,e,n){a.output={src:e,format:n}},changePixel:function(t,e,n,r){return[t,e,n,r]},extraManipulation:function(t){for(var n=[0,0,0,0],r=0;rAverages (r, g, b, a): "+n.join(", ")+"

"),t},format:n.format,image:e.image,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":235}],162:[function(t,e,n){e.exports=[t("./Module"),t("./info.json")]},{"./Module":161,"./info.json":163}],163:[function(t,e,n){e.exports={name:"Average",description:"Average all pixel color",inputs:{}}},{}],164:[function(require,module,exports){module.exports=function Dynamic(options,UI,util){var output;function draw(input,callback,progressObj){progressObj.stop(!0),progressObj.overrideFlag=!0;var step=this;"string"==typeof options.func&&eval("options.func = "+options.func);var getPixels=require("get-pixels");"string"==typeof options.offset&&(options.offset=parseInt(options.offset));var priorStep=this.getStep(options.offset);getPixels(priorStep.output.src,function(t,e){return options.firstImagePixels=e,require("../_nomodule/PixelManipulation.js")(input,{output:function(t,e,n){step.output={src:e,format:n}},changePixel:function(t,e,n,r,i,a){var o=options.firstImagePixels;return options.func(t,e,n,r,o.get(i,a,0),o.get(i,a,1),o.get(i,a,2),o.get(i,a,3))},format:input.format,image:options.image,inBrowser:options.inBrowser,callback:callback})})}return options.func=options.func||"function(r1, g1, b1, a1, r2, g2, b2, a2) { return [ r1, g2, b2, a2 ] }",options.offset=options.offset||-2,{options:options,draw:draw,output:output,UI:UI}}},{"../_nomodule/PixelManipulation.js":235,"get-pixels":30}],165:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":164,"./info.json":166,dup:162}],166:[function(t,e,n){e.exports={name:"Blend",description:"Blend two chosen image steps with the given function. Defaults to using the red channel from image 1 and the green and blue and alpha channels of image 2. Easier to use interfaces coming soon!",inputs:{offset:{type:"integer",desc:"Choose which image to blend the current image with. Two steps back is -2, three steps back is -3 etc.",default:-2},blend:{type:"input",desc:"Function to use to blend the two images.",default:"function(r1, g1, b1, a1, r2, g2, b2, a2) { return [ r1, g2, b2, a2 ] }"}}}},{}],167:[function(t,e,n){e.exports=function(t,e){let n=[[2/159,4/159,5/159,4/159,2/159],[4/159,9/159,12/159,9/159,4/159],[5/159,12/159,15/159,12/159,5/159],[4/159,9/159,12/159,9/159,4/159],[2/159,4/159,5/159,4/159,2/159]],r=t;n=function(t){let e=[];for(let n=t.length-1;n>=0;n--){let r=[];for(let e=t[n].length-1;e>=0;e--)r.push(t[n][e]);e.push(r)}return e}(n);for(let e=0;ev;n=0<=v?++c:--c)r[n]=(e-i)/(a-i)*(u[n]-s[n])+s[n];return r}}e.exports=function(t,e){return e.colormap=e.colormap||i.default,"object"==typeof e.colormap?colormapFunction=r(e.colormap):i.hasOwnProperty(e.colormap)?colormapFunction=i[e.colormap]:colormapFunction=i.default,colormapFunction(t/255)};var i={greyscale:r([[0,[0,0,0],[255,255,255]],[1,[255,255,255],[255,255,255]]]),default:r([[0,[0,0,255],[0,255,0]],[.25,[0,255,0],[255,255,0]],[.5,[0,255,255],[255,255,0]],[.75,[255,255,0],[255,0,0]]]),ndvi:r([[0,[0,0,255],[38,195,195]],[.5,[0,150,0],[255,255,0]],[.75,[255,255,0],[255,50,50]]]),stretched:r([[0,[0,0,255],[0,0,255]],[.1,[0,0,255],[38,195,195]],[.5,[0,150,0],[255,255,0]],[.7,[255,255,0],[255,50,50]],[.9,[255,50,50],[255,50,50]]]),fastie:r([[0,[255,255,255],[0,0,0]],[.167,[0,0,0],[255,255,255]],[.33,[255,255,255],[0,0,0]],[.5,[0,0,0],[140,140,255]],[.55,[140,140,255],[0,255,0]],[.63,[0,255,0],[255,255,0]],[.75,[255,255,0],[255,0,0]],[.95,[255,0,0],[255,0,255]]])}},{}],181:[function(t,e,n){e.exports=function(e,n){return{options:e,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return t("../_nomodule/PixelManipulation.js")(n,{output:function(t,e,n){a.output={src:e,format:n}},changePixel:function(n,r,i,a){var o=(n+r+i)/3,s=t("./Colormap")(o,e);return[s[0],s[1],s[2],255]},format:n.format,image:e.image,inBrowser:e.inBrowser,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":235,"./Colormap":180}],182:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":181,"./info.json":183,dup:162}],183:[function(t,e,n){e.exports={name:"Colormap",description:"Maps brightness values (average of red, green & blue) to a given color lookup table, made up of a set of one more color gradients.\n\nFor example, 'cooler' colors like blue could represent low values, while 'hot' colors like red could represent high values.",inputs:{colormap:{type:"select",desc:"Name of the Colormap",default:"default",values:["default","greyscale","stretched","fastie"]}}}},{}],184:[function(t,e,n){var r=t("lodash");e.exports=function(t,e,n){let a=function(t,e){for(e=e.split(" "),i=0;i<9;i++)e[i]=Number(e[i])*t;let n=0,r=[];for(i=0;i<3;i++){let t=[];for(j=0;j<3;j++)t.push(e[n]),n+=1;r.push(t)}return r}(e,n),o=r.cloneDeep(t);a=function(t){let e=[];for(let n=t.length-1;n>=0;n--){let r=[];for(let e=t[n].length-1;e>=0;e--)r.push(t[n][e]);e.push(r)}return e}(a);for(let e=0;eRead more",inputs:{constantFactor:{type:"Float",desc:"a constant factor, multiplies all the kernel values by that factor",default:.1111,placeholder:.1111},kernelValues:{type:"String",desc:"nine space separated numbers representing the kernel values in left to right and top to bottom format.",default:"1 1 1 1 1 1 1 1 1",placeholder:"1 1 1 1 1 1 1 1 1"}}}},{}],188:[function(t,e,n){(function(n){e.exports=function(e,r,i){var a=t("get-pixels"),o=t("save-pixels");r.x=parseInt(r.x)||0,r.y=parseInt(r.y)||0,a(e.src,function(t,a){r.w=parseInt(r.w)||Math.floor(a.shape[0]),r.h=parseInt(r.h)||Math.floor(a.shape[1]);for(var s=r.x,u=r.y,l=r.w,c=r.h,f=a.shape[0],h=new Uint8Array(4*l*c),p=u;pInfragrammar.",inputs:{red:{type:"input",desc:"Expression to return for red channel with R, G, B, and A inputs",default:"r"},green:{type:"input",desc:"Expression to return for green channel with R, G, B, and A inputs",default:"g"},blue:{type:"input",desc:"Expression to return for blue channel with R, G, B, and A inputs",default:"b"},"monochrome (fallback)":{type:"input",desc:"Expression to return with R, G, B, and A inputs; fallback for other channels if none provided",default:"r + g + b"}}}},{}],199:[function(t,e,n){t("lodash");const r=[[-1,0,1],[-2,0,2],[-1,0,1]],i=[[-1,-2,-1],[0,0,0],[1,2,1]];function a(t,e,n,a,o){let s=0;for(let e=0;e<3;e++)for(let n=0;n<3;n++){let i=a+e-1,u=o+n-1;s+=t.get(i,u,0)*r[e][n]}let u=0;for(let e=0;e<3;e++)for(let n=0;n<3;n++){let r=a+e-1,s=o+n-1;u+=t.get(r,s,0)*i[e][n]}return{pixel:[e,e,e,Math.sqrt(Math.pow(s,2)+Math.pow(u,2))],angle:Math.atan2(u,s)}}e.exports=function(t,e,n,r){let i=[],u=[];for(var l=0;lt.map(o));for(let r=1;r=-22.5&&a<=22.5||a<-157.5&&a>=-180?e[r][i]>=e[r][i+1]&&e[r][i]>=e[r][i-1]?t.set(r,i,3,e[r][i]):t.set(r,i,3,0):a>=22.5&&a<=67.5||a<-112.5&&a>=-157.5?e[r][i]>=e[r+1][i+1]&&e[r][i]>=e[r-1][i-1]?t.set(r,i,3,e[r][i]):t.set(r,i,3,0):a>=67.5&&a<=112.5||a<-67.5&&a>=-112.5?e[r][r]>=e[r+1][i]&&e[r][i]>=e[r][i]?t.set(r,i,3,e[r][i]):t.set(r,i,3,0):(a>=112.5&&a<=157.5||a<-22.5&&a>=-67.5)&&(e[r][i]>=e[r+1][i-1]&&e[r][i]>=e[r-1][i+1]?t.set(r,i,3,e[r][i]):t.set(r,i,3,0))}}(t,u,i),function(t,e,n,r,i,a){const o=s(r)*e,u=o*n;for(let e=0;eu?r[e][n]>o?i.push(s):a.push(s):t.set(e,n,3,0)}i.forEach(e=>t.set(e[0],e[1],3,255))}(t,e,n,u,[],[]),t};var o=t=>180*t/Math.PI,s=t=>Math.max(...t.map(t=>t.map(t=>t||0)).map(t=>Math.max(...t)))},{lodash:75}],200:[function(t,e,n){e.exports=function(e,n){return e.blur=e.blur||2,e.highThresholdRatio=e.highThresholdRatio||.2,e.lowThresholdRatio=e.lowThresholdRatio||.15,{options:e,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return t("../_nomodule/PixelManipulation.js")(n,{output:function(t,e,n){a.output={src:e,format:n}},changePixel:function(t,e,n,r){return[(t+e+n)/3,(t+e+n)/3,(t+e+n)/3,r]},extraManipulation:function(n){return n=t("ndarray-gaussian-filter")(n,e.blur),n=t("./EdgeUtils")(n,e.highThresholdRatio,e.lowThresholdRatio,e.inBrowser)},format:n.format,image:e.image,inBrowser:e.inBrowser,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":235,"./EdgeUtils":199,"ndarray-gaussian-filter":80}],201:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":200,"./info.json":202,dup:162}],202:[function(t,e,n){e.exports={name:"Detect Edges",description:"this module detects edges using the Canny method, which first Gaussian blurs the image to reduce noise (amount of blur configurable in settings as `options.blur`), then applies a number of steps to highlight edges, resulting in a greyscale image where the brighter the pixel, the stronger the detected edge. Read more. ",inputs:{blur:{type:"integer",desc:"amount of gaussian blur(Less blur gives more detail, typically 0-5)",default:2},highThresholdRatio:{type:"float",desc:"The high threshold ratio for the image",default:.2},lowThresholdRatio:{type:"float",desc:"The low threshold value for the image",default:.15}}}},{}],203:[function(t,e,n){e.exports=function(e,n){return t("fisheyegl"),{options:e,draw:function(t,n){var r=this;if(e.inBrowser){if(document.querySelector("#image-sequencer-canvas"))var i=document.querySelector("#image-sequencer-canvas");else(i=document.createElement("canvas")).style.display="none",i.setAttribute("id","image-sequencer-canvas"),document.body.append(i);distorter=FisheyeGl({selector:"#image-sequencer-canvas"}),e.a=parseFloat(e.a)||distorter.lens.a,e.b=parseFloat(e.b)||distorter.lens.b,e.Fx=parseFloat(e.Fx)||distorter.lens.Fx,e.Fy=parseFloat(e.Fy)||distorter.lens.Fy,e.scale=parseFloat(e.scale)||distorter.lens.scale,e.x=parseFloat(e.x)||distorter.fov.x,e.y=parseFloat(e.y)||distorter.fov.y,distorter.lens.a=e.a,distorter.lens.b=e.b,distorter.lens.Fx=e.Fx,distorter.lens.Fy=e.Fy,distorter.lens.scale=e.scale,distorter.fov.x=e.x,distorter.fov.y=e.y,distorter.setImage(t.src,function(){r.output={src:i.toDataURL(),format:t.format},n()})}else this.output=t,n()},output:void 0,UI:n}}},{fisheyegl:22}],204:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":203,"./info.json":205,dup:162}],205:[function(t,e,n){e.exports={name:"Fisheye GL",description:"Correct fisheye, or barrel distortion, in images (with WebGL -- adapted from fisheye-correction-webgl by @bluemir).",requires:["webgl"],inputs:{a:{type:"float",desc:"a parameter",default:1,min:1,max:4},b:{type:"float",desc:"b parameter",default:1,min:1,max:4},Fx:{type:"float",desc:"Fx parameter",default:0,min:0,max:4},Fy:{type:"float",desc:"Fy parameter",default:0,min:0,max:4},scale:{type:"float",desc:"Image Scaling",default:1.5,min:0,max:20},x:{type:"float",desc:"FOV x parameter",default:1.5,min:0,max:20},y:{type:"float",desc:"FOV y parameter",default:1.5,min:0,max:20},fragmentSrc:{type:"PATH",desc:"Path to a WebGL fragment shader file",default:"(inbuilt)"},vertexSrc:{type:"PATH",desc:"Path to a WebGL vertex shader file",default:"(inbuilt)"}}}},{}],206:[function(t,e,n){e.exports=function(e,n){return{options:e,draw:function(n,r,i){i.stop(!0),i.overrideFlag=!0;var a=this;return t("../_nomodule/PixelManipulation.js")(n,{output:function(t,e,n){a.output={src:e,format:n}},changePixel:function(t,n,r,i){var a=e.adjustment||.2;return[t=255*Math.pow(t/255,a),n=255*Math.pow(n/255,a),r=255*Math.pow(r/255,a),i]},format:n.format,image:e.image,inBrowser:e.inBrowser,callback:r})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":235}],207:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":206,"./info.json":208,dup:162}],208:[function(t,e,n){e.exports={name:"Gamma Correction",description:"Apply gamma correction on the image Read more",inputs:{adjustment:{type:"float",desc:"gamma correction (inverse of actual gamma factor) for the new image",default:.2}}}},{}],209:[function(t,e,n){(function(n){e.exports=function(e,r){return{options:e,draw:function(e,r,i){var a=t("get-pixels"),o=t("save-pixels"),s=this;a(e.src,function(t,i){if(t)console.log("Bad Image path");else{for(var a=0,u=0;u

Select or drag in an image to overlay.

';$(t.ui).find(".details").prepend(i),sequencer.setInputStep({dropZoneSelector:"#"+r,fileInputSelector:"#"+r+" .file-input",onLoad:function(e){var n=e.target;t.options.imageUrl=n.result,t.options.url=n.result,sequencer.run(),setUrlHashParameter("steps",sequencer.toString())}}),$(t.ui).find(".btn-save").on("click",function(){var e=$(t.ui).find(".det input").val();t.options.imageUrl=e,sequencer.run()})}}}},{}],217:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":215,"./info.json":218,dup:162}],218:[function(t,e,n){e.exports={name:"Import Image",description:"Import a new image and replace the original with it. Future versions may enable a blend mode. Specify an image by URL or by file selector.",url:"https://github.com/publiclab/image-sequencer/tree/master/MODULES.md",inputs:{url:{type:"string",desc:"URL of image to import",default:"./images/monarch.png"}}}},{}],219:[function(t,e,n){e.exports=function(e,n){if(e.step.inBrowser)var r=t("./Ui.js")(e.step,n);return e.filter=e.filter||"red",{options:e,draw:function(n,i,a){a.stop(!0),a.overrideFlag=!0;var o=this;return t("../_nomodule/PixelManipulation.js")(n,{output:function(t,e,n){o.output={src:e,format:n}},changePixel:function(t,n,r,i){if("red"==e.filter)var a=(r-t)/(1*r+t);"blue"==e.filter&&(a=(t-r)/(1*r+t));var o=255*(a+1)/2;return[o,o,o,i]},format:n.format,image:e.image,inBrowser:e.inBrowser,callback:function(){e.step.inBrowser&&r.setup(),i()}})},output:void 0,UI:n}}},{"../_nomodule/PixelManipulation.js":235,"./Ui.js":220}],220:[function(t,e,n){e.exports=function(t,e){return{setup:function(){var e=$(t.imgElement);e.mousemove(function(t){var n=document.createElement("canvas");n.width=e.width(),n.height=e.height(),n.getContext("2d").drawImage(this,0,0);var r=$(this).offset(),i=t.pageX-r.left,a=t.pageY-r.top,o=n.getContext("2d").getImageData(i,a,1,1).data[0];o=(o=o/127.5-1).toFixed(2),e[0].title="NDVI: "+o})}}}},{}],221:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":219,"./info.json":222,dup:162}],222:[function(t,e,n){e.exports={name:"NDVI",description:"Normalized Difference Vegetation Index, or NDVI, is an image analysis technique used with aerial photography. It's a way to visualize the amounts of infrared and other wavelengths of light reflected from vegetation by comparing ratios of blue and red light absorbed versus green and IR light reflected. NDVI is used to evaluate the health of vegetation in satellite imagery, where it correlates with how much photosynthesis is happening. This is helpful in assessing vegetative health or stress. Read more.

This is designed for use with red-filtered single camera DIY Infragram cameras; change to 'blue' for blue filters",inputs:{filter:{type:"select",desc:"Filter color",default:"red",values:["red","blue"]}}}},{}],223:[function(t,e,n){e.exports=function(){return this.expandSteps([{name:"ndvi",options:{}},{name:"colormap",options:{}}]),{isMeta:!0}}},{}],224:[function(t,e,n){arguments[4][162][0].apply(n,arguments)},{"./Module":223,"./info.json":225,dup:162}],225:[function(t,e,n){e.exports={name:"NDVI-Colormap",description:"Sequentially Applies NDVI and Colormap steps",inputs:{},length:2}},{}],226:[function(t,e,n){e.exports=function(e,n,r){return e.x=e.x||0,e.y=e.y||0,{options:e,draw:function(n,r,i){e.offset=e.offset||-2,i.stop(!0),i.overrideFlag=!0;var a=this,o=this.getStep(e.offset).image,s=this.getOutput(e.offset);t("get-pixels")(n.src,function(n,i){return e.secondImagePixels=i,t("../_nomodule/PixelManipulation.js")(s,{output:function(t,e,n){a.output={src:e,format:n}},changePixel:function(t,n,r,i,a,o){var s=e.secondImagePixels;return a>=e.x&&a=e.y&&o
To work with a new or different image, drag one into the drop zone.",ID:e.options.sequencerCounter++,imageName:t,inBrowser:e.options.inBrowser,ui:e.options.ui},o={src:n,steps:[{options:{id:r.ID,name:"load-image",description:"This initial step loads and displays the original image without any modifications.",title:"Load Image",step:r},UI:e.events,draw:function(){return UI.onDraw(options.step),1==arguments.length?(this.output=a(arguments[0]),options.step.output=this.output,UI.onComplete(options.step),!0):2==arguments.length&&(this.output=a(arguments[0]),options.step.output=this.output,arguments[1](),UI.onComplete(options.step),!0)}}]};a(n,function(n){var r=function(t){return{src:t,format:t.split(":")[1].split(";")[0].split("/")[1]}}(n);e.images[t]=o;var a=e.images[t].steps[0];return a.output=r,a.options.step.output=a.output.src,a.UI.onSetup(a.options.step),a.UI.onDraw(a.options.step),a.UI.onComplete(a.options.step),i(),!0})}(n,r)}},{urify:147}],237:[function(t,e,n){e.exports=function(){return function(t){var e=$(t.dropZoneSelector),n=$(t.fileInputSelector),r=t.onLoad;function i(t){if(t.preventDefault(),t.stopPropagation(),t.target&&t.target.files)var e=t.target.files[0];else e=t.dataTransfer.files[0];if(e){var n=new FileReader;n.onload=r,n.readAsDataURL(e)}}new FileReader,n.on("change",i),e[0].addEventListener("drop",i,!1),e.on("dragover",function(t){t.stopPropagation(),t.preventDefault(),t.dataTransfer.dropEffect="copy"},!1),e.on("dragenter",function(t){e.addClass("hover")}),e.on("dragleave",function(t){e.removeClass("hover")})}}},{}],238:[function(t,e,n){e.exports=function(t={}){return t.onSetup=t.onSetup||function(t){0==t.ui||(t.inBrowser?console.log('Added Step "'+t.name+'" to "'+t.imageName+'".'):console.log("%s",'Added Step "'+t.name+'" to "'+t.imageName+'".'))},t.onDraw=t.onDraw||function(t){0==t.ui||(t.inBrowser?console.log('Drawing Step "'+t.name+'" on "'+t.imageName+'".'):console.log("%s",'Drawing Step "'+t.name+'" on "'+t.imageName+'".'))},t.onComplete=t.onComplete||function(t){0==t.ui||(t.inBrowser?console.log('Drawn Step "'+t.name+'" on "'+t.imageName+'".'):console.log("%s",'Drawn Step "'+t.name+'" on "'+t.imageName+'".'))},t.onRemove=t.onRemove||function(t){0==t.ui||(t.inBrowser?console.log('Removing Step "'+t.name+'" of "'+t.imageName+'".'):console.log("%s",'Removing Step "'+t.name+'" of "'+t.imageName+'".'))},t}},{}],239:[function(t,e,n){e.exports=function(t){var e=void 0;return"jpeg"===(e=(e=function(t){return"data:image"===t.substr(0,10)}(t)?t.split(";")[0].split("/").pop():t.split(".").pop()).toLowerCase())&&(e="jpg"),["jpg","jpeg","png","gif","canvas"].includes(e)?e:"jpg"}},{}],240:[function(t,e,n){e.exports={getPreviousStep:function(){return this.getStep(-1)},getNextStep:function(){return this.getStep(1)},getInput:function(t){return t+this.getIndex()===0&&t++,this.getStep(t-1).output},getOutput:function(t){return this.getStep(t).output},getOptions:function(){return this.getStep(0).options},setOptions:function(t){let e=this.getStep(0).options;for(let n in t)e[n]&&(e[n]=t[n])},getFormat:function(){return this.getStep(-1).output.format},getHeight:function(t){let e=new Image;e.onload=function(){t(e.height)},e.src=this.getInput(0).src},getWidth:function(t){let e=new Image;e.onload=function(){t(e.width)},e.src=this.getInput(0).src}}},{}]},{},[154]); \ No newline at end of file diff --git a/src/modules/Dynamic/Module.js b/src/modules/Dynamic/Module.js index 16c508d7..9f281f7b 100644 --- a/src/modules/Dynamic/Module.js +++ b/src/modules/Dynamic/Module.js @@ -54,6 +54,22 @@ module.exports = function Dynamic(options,UI) { ] } + // via P5js: https://github.com/processing/p5.js/blob/2920492842aae9a8bf1a779916893ac19d65cd38/src/math/calculation.js#L461-L472 + function map(n, start1, stop1, start2, stop2, withinBounds) { + var newval = (n - start1) / (stop1 - start1) * (stop2 - start2) + start2; + if (!withinBounds) { + return newval; + } + // also via P5js: https://github.com/processing/p5.js/blob/2920492842aae9a8bf1a779916893ac19d65cd38/src/math/calculation.js#L116-L119 + function constrain(n, low, high) { + return Math.max(Math.min(n, high), low); + }; + if (start2 < stop2) { + return constrain(newval, start2, stop2); + } else { + return constrain(newval, stop2, start2); + } + }; function output(image,datauri,mimetype){