|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
|
module.exports = factory(require("get-pixels"), require("ndarray"), require("ndarray-linear-interpolate"));
|
|
|
else if(typeof define === 'function' && define.amd)
|
|
|
define(["get-pixels", "ndarray", "ndarray-linear-interpolate"], factory);
|
|
|
else if(typeof exports === 'object')
|
|
|
exports["Quagga"] = factory(require("get-pixels"), require("ndarray"), require("ndarray-linear-interpolate"));
|
|
|
else
|
|
|
root["Quagga"] = factory(root["get-pixels"], root["ndarray"], root["ndarray-linear-interpolate"]);
|
|
|
})(this, function(__WEBPACK_EXTERNAL_MODULE_211__, __WEBPACK_EXTERNAL_MODULE_212__, __WEBPACK_EXTERNAL_MODULE_213__) {
|
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
|
/******/ // The module cache
|
|
|
/******/ var installedModules = {};
|
|
|
/******/
|
|
|
/******/ // The require function
|
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
/******/
|
|
|
/******/ // Check if module is in cache
|
|
|
/******/ if(installedModules[moduleId])
|
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
/******/
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
|
/******/ var module = installedModules[moduleId] = {
|
|
|
/******/ i: moduleId,
|
|
|
/******/ l: false,
|
|
|
/******/ exports: {}
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // Execute the module function
|
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
/******/
|
|
|
/******/ // Flag the module as loaded
|
|
|
/******/ module.l = true;
|
|
|
/******/
|
|
|
/******/ // Return the exports of the module
|
|
|
/******/ return module.exports;
|
|
|
/******/ }
|
|
|
/******/
|
|
|
/******/
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
|
/******/ __webpack_require__.m = modules;
|
|
|
/******/
|
|
|
/******/ // expose the module cache
|
|
|
/******/ __webpack_require__.c = installedModules;
|
|
|
/******/
|
|
|
/******/ // identity function for calling harmony imports with the correct context
|
|
|
/******/ __webpack_require__.i = function(value) { return value; };
|
|
|
/******/
|
|
|
/******/ // define getter function for harmony exports
|
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
|
/******/ Object.defineProperty(exports, name, {
|
|
|
/******/ configurable: false,
|
|
|
/******/ enumerable: true,
|
|
|
/******/ get: getter
|
|
|
/******/ });
|
|
|
/******/ }
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
|
/******/ __webpack_require__.n = function(module) {
|
|
|
/******/ var getter = module && module.__esModule ?
|
|
|
/******/ function getDefault() { return module['default']; } :
|
|
|
/******/ function getModuleExports() { return module; };
|
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
|
/******/ return getter;
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
|
/******/
|
|
|
/******/ // __webpack_public_path__
|
|
|
/******/ __webpack_require__.p = "/";
|
|
|
/******/
|
|
|
/******/ // Load entry module and return exports
|
|
|
/******/ return __webpack_require__(__webpack_require__.s = 214);
|
|
|
/******/ })
|
|
|
/************************************************************************/
|
|
|
/******/ ([
|
|
|
/* 0 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
var logDisabled_ = true;
|
|
|
|
|
|
// Utility methods.
|
|
|
var utils = {
|
|
|
disableLog: function(bool) {
|
|
|
if (typeof bool !== 'boolean') {
|
|
|
return new Error('Argument type: ' + typeof bool +
|
|
|
'. Please use a boolean.');
|
|
|
}
|
|
|
logDisabled_ = bool;
|
|
|
return (bool) ? 'adapter.js logging disabled' :
|
|
|
'adapter.js logging enabled';
|
|
|
},
|
|
|
|
|
|
log: function() {
|
|
|
if (typeof window === 'object') {
|
|
|
if (logDisabled_) {
|
|
|
return;
|
|
|
}
|
|
|
if (typeof console !== 'undefined' && typeof console.log === 'function') {
|
|
|
console.log.apply(console, arguments);
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* Extract browser version out of the provided user agent string.
|
|
|
*
|
|
|
* @param {!string} uastring userAgent string.
|
|
|
* @param {!string} expr Regular expression used as match criteria.
|
|
|
* @param {!number} pos position in the version string to be returned.
|
|
|
* @return {!number} browser version.
|
|
|
*/
|
|
|
extractVersion: function(uastring, expr, pos) {
|
|
|
var match = uastring.match(expr);
|
|
|
return match && match.length >= pos && parseInt(match[pos], 10);
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* Browser detector.
|
|
|
*
|
|
|
* @return {object} result containing browser and version
|
|
|
* properties.
|
|
|
*/
|
|
|
detectBrowser: function() {
|
|
|
// Returned result object.
|
|
|
var result = {};
|
|
|
result.browser = null;
|
|
|
result.version = null;
|
|
|
|
|
|
// Fail early if it's not a browser
|
|
|
if (typeof window === 'undefined' || !window.navigator) {
|
|
|
result.browser = 'Not a browser.';
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
// Firefox.
|
|
|
if (navigator.mozGetUserMedia) {
|
|
|
result.browser = 'firefox';
|
|
|
result.version = this.extractVersion(navigator.userAgent,
|
|
|
/Firefox\/([0-9]+)\./, 1);
|
|
|
|
|
|
// all webkit-based browsers
|
|
|
} else if (navigator.webkitGetUserMedia) {
|
|
|
// Chrome, Chromium, Webview, Opera, all use the chrome shim for now
|
|
|
if (window.webkitRTCPeerConnection) {
|
|
|
result.browser = 'chrome';
|
|
|
result.version = this.extractVersion(navigator.userAgent,
|
|
|
/Chrom(e|ium)\/([0-9]+)\./, 2);
|
|
|
|
|
|
// Safari or unknown webkit-based
|
|
|
// for the time being Safari has support for MediaStreams but not webRTC
|
|
|
} else {
|
|
|
// Safari UA substrings of interest for reference:
|
|
|
// - webkit version: AppleWebKit/602.1.25 (also used in Op,Cr)
|
|
|
// - safari UI version: Version/9.0.3 (unique to Safari)
|
|
|
// - safari UI webkit version: Safari/601.4.4 (also used in Op,Cr)
|
|
|
//
|
|
|
// if the webkit version and safari UI webkit versions are equals,
|
|
|
// ... this is a stable version.
|
|
|
//
|
|
|
// only the internal webkit version is important today to know if
|
|
|
// media streams are supported
|
|
|
//
|
|
|
if (navigator.userAgent.match(/Version\/(\d+).(\d+)/)) {
|
|
|
result.browser = 'safari';
|
|
|
result.version = this.extractVersion(navigator.userAgent,
|
|
|
/AppleWebKit\/([0-9]+)\./, 1);
|
|
|
|
|
|
// unknown webkit-based browser
|
|
|
} else {
|
|
|
result.browser = 'Unsupported webkit-based browser ' +
|
|
|
'with GUM support but no WebRTC support.';
|
|
|
return result;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Edge.
|
|
|
} else if (navigator.mediaDevices &&
|
|
|
navigator.userAgent.match(/Edge\/(\d+).(\d+)$/)) {
|
|
|
result.browser = 'edge';
|
|
|
result.version = this.extractVersion(navigator.userAgent,
|
|
|
/Edge\/(\d+).(\d+)$/, 2);
|
|
|
|
|
|
// Default fallthrough: not supported.
|
|
|
} else {
|
|
|
result.browser = 'Not a supported browser.';
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// Export.
|
|
|
module.exports = {
|
|
|
log: utils.log,
|
|
|
disableLog: utils.disableLog,
|
|
|
browserDetails: utils.detectBrowser(),
|
|
|
extractVersion: utils.extractVersion
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 1 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var freeGlobal = __webpack_require__(58);
|
|
|
|
|
|
/** Detect free variable `self`. */
|
|
|
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
|
|
|
|
|
|
/** Used as a reference to the global object. */
|
|
|
var root = freeGlobal || freeSelf || Function('return this')();
|
|
|
|
|
|
module.exports = root;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 2 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is classified as an `Array` object.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isArray([1, 2, 3]);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArray(document.body.children);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isArray('abc');
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isArray(_.noop);
|
|
|
* // => false
|
|
|
*/
|
|
|
var isArray = Array.isArray;
|
|
|
|
|
|
module.exports = isArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 3 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is the
|
|
|
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
|
|
|
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isObject({});
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isObject([1, 2, 3]);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isObject(_.noop);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isObject(null);
|
|
|
* // => false
|
|
|
*/
|
|
|
function isObject(value) {
|
|
|
var type = typeof value;
|
|
|
return value != null && (type == 'object' || type == 'function');
|
|
|
}
|
|
|
|
|
|
module.exports = isObject;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 4 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseIsNative = __webpack_require__(122),
|
|
|
getValue = __webpack_require__(152);
|
|
|
|
|
|
/**
|
|
|
* Gets the native function at `key` of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @param {string} key The key of the method to get.
|
|
|
* @returns {*} Returns the function if it's native, else `undefined`.
|
|
|
*/
|
|
|
function getNative(object, key) {
|
|
|
var value = getValue(object, key);
|
|
|
return baseIsNative(value) ? value : undefined;
|
|
|
}
|
|
|
|
|
|
module.exports = getNative;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 5 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _merge2 = __webpack_require__(40);
|
|
|
|
|
|
var _merge3 = _interopRequireDefault(_merge2);
|
|
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
|
|
var _barcode_reader = __webpack_require__(10);
|
|
|
|
|
|
var _barcode_reader2 = _interopRequireDefault(_barcode_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function EANReader(opts, supplements) {
|
|
|
opts = (0, _merge3.default)(getDefaulConfig(), opts);
|
|
|
_barcode_reader2.default.call(this, opts, supplements);
|
|
|
}
|
|
|
|
|
|
function getDefaulConfig() {
|
|
|
var config = {};
|
|
|
|
|
|
Object.keys(EANReader.CONFIG_KEYS).forEach(function (key) {
|
|
|
config[key] = EANReader.CONFIG_KEYS[key].default;
|
|
|
});
|
|
|
return config;
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
CODE_L_START: { value: 0 },
|
|
|
CODE_G_START: { value: 10 },
|
|
|
START_PATTERN: { value: [1, 1, 1] },
|
|
|
STOP_PATTERN: { value: [1, 1, 1] },
|
|
|
MIDDLE_PATTERN: { value: [1, 1, 1, 1, 1] },
|
|
|
EXTENSION_START_PATTERN: { value: [1, 1, 2] },
|
|
|
CODE_PATTERN: { value: [[3, 2, 1, 1], [2, 2, 2, 1], [2, 1, 2, 2], [1, 4, 1, 1], [1, 1, 3, 2], [1, 2, 3, 1], [1, 1, 1, 4], [1, 3, 1, 2], [1, 2, 1, 3], [3, 1, 1, 2], [1, 1, 2, 3], [1, 2, 2, 2], [2, 2, 1, 2], [1, 1, 4, 1], [2, 3, 1, 1], [1, 3, 2, 1], [4, 1, 1, 1], [2, 1, 3, 1], [3, 1, 2, 1], [2, 1, 1, 3]] },
|
|
|
CODE_FREQUENCY: { value: [0, 11, 13, 14, 19, 25, 28, 21, 22, 26] },
|
|
|
SINGLE_CODE_ERROR: { value: 0.70 },
|
|
|
AVG_CODE_ERROR: { value: 0.48 },
|
|
|
FORMAT: { value: "ean_13", writeable: false }
|
|
|
};
|
|
|
|
|
|
EANReader.prototype = Object.create(_barcode_reader2.default.prototype, properties);
|
|
|
EANReader.prototype.constructor = EANReader;
|
|
|
|
|
|
EANReader.prototype._decodeCode = function (start, coderange) {
|
|
|
var counter = [0, 0, 0, 0],
|
|
|
i,
|
|
|
self = this,
|
|
|
offset = start,
|
|
|
isWhite = !self._row[offset],
|
|
|
counterPos = 0,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: start,
|
|
|
end: start
|
|
|
},
|
|
|
code,
|
|
|
error;
|
|
|
|
|
|
if (!coderange) {
|
|
|
coderange = self.CODE_PATTERN.length;
|
|
|
}
|
|
|
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
for (code = 0; code < coderange; code++) {
|
|
|
error = self._matchPattern(counter, self.CODE_PATTERN[code]);
|
|
|
if (error < bestMatch.error) {
|
|
|
bestMatch.code = code;
|
|
|
bestMatch.error = error;
|
|
|
}
|
|
|
}
|
|
|
bestMatch.end = i;
|
|
|
if (bestMatch.error > self.AVG_CODE_ERROR) {
|
|
|
return null;
|
|
|
}
|
|
|
return bestMatch;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._findPattern = function (pattern, offset, isWhite, tryHarder, epsilon) {
|
|
|
var counter = [],
|
|
|
self = this,
|
|
|
i,
|
|
|
counterPos = 0,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: 0,
|
|
|
end: 0
|
|
|
},
|
|
|
error,
|
|
|
j,
|
|
|
sum;
|
|
|
|
|
|
if (!offset) {
|
|
|
offset = self._nextSet(self._row);
|
|
|
}
|
|
|
|
|
|
if (isWhite === undefined) {
|
|
|
isWhite = false;
|
|
|
}
|
|
|
|
|
|
if (tryHarder === undefined) {
|
|
|
tryHarder = true;
|
|
|
}
|
|
|
|
|
|
if (epsilon === undefined) {
|
|
|
epsilon = self.AVG_CODE_ERROR;
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < pattern.length; i++) {
|
|
|
counter[i] = 0;
|
|
|
}
|
|
|
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
sum = 0;
|
|
|
for (j = 0; j < counter.length; j++) {
|
|
|
sum += counter[j];
|
|
|
}
|
|
|
error = self._matchPattern(counter, pattern);
|
|
|
|
|
|
if (error < epsilon) {
|
|
|
bestMatch.error = error;
|
|
|
bestMatch.start = i - sum;
|
|
|
bestMatch.end = i;
|
|
|
return bestMatch;
|
|
|
}
|
|
|
if (tryHarder) {
|
|
|
for (j = 0; j < counter.length - 2; j++) {
|
|
|
counter[j] = counter[j + 2];
|
|
|
}
|
|
|
counter[counter.length - 2] = 0;
|
|
|
counter[counter.length - 1] = 0;
|
|
|
counterPos--;
|
|
|
} else {
|
|
|
return null;
|
|
|
}
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._findStart = function () {
|
|
|
var self = this,
|
|
|
leadingWhitespaceStart,
|
|
|
offset = self._nextSet(self._row),
|
|
|
startInfo;
|
|
|
|
|
|
while (!startInfo) {
|
|
|
startInfo = self._findPattern(self.START_PATTERN, offset);
|
|
|
if (!startInfo) {
|
|
|
return null;
|
|
|
}
|
|
|
leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);
|
|
|
if (leadingWhitespaceStart >= 0) {
|
|
|
if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
|
|
|
return startInfo;
|
|
|
}
|
|
|
}
|
|
|
offset = startInfo.end;
|
|
|
startInfo = null;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._verifyTrailingWhitespace = function (endInfo) {
|
|
|
var self = this,
|
|
|
trailingWhitespaceEnd;
|
|
|
|
|
|
trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);
|
|
|
if (trailingWhitespaceEnd < self._row.length) {
|
|
|
if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
|
|
|
return endInfo;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._findEnd = function (offset, isWhite) {
|
|
|
var self = this,
|
|
|
endInfo = self._findPattern(self.STOP_PATTERN, offset, isWhite, false);
|
|
|
|
|
|
return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._calculateFirstDigit = function (codeFrequency) {
|
|
|
var i,
|
|
|
self = this;
|
|
|
|
|
|
for (i = 0; i < self.CODE_FREQUENCY.length; i++) {
|
|
|
if (codeFrequency === self.CODE_FREQUENCY[i]) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._decodePayload = function (code, result, decodedCodes) {
|
|
|
var i,
|
|
|
self = this,
|
|
|
codeFrequency = 0x0,
|
|
|
firstDigit;
|
|
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
code = self._decodeCode(code.end);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
if (code.code >= self.CODE_G_START) {
|
|
|
code.code = code.code - self.CODE_G_START;
|
|
|
codeFrequency |= 1 << 5 - i;
|
|
|
} else {
|
|
|
codeFrequency |= 0 << 5 - i;
|
|
|
}
|
|
|
result.push(code.code);
|
|
|
decodedCodes.push(code);
|
|
|
}
|
|
|
|
|
|
firstDigit = self._calculateFirstDigit(codeFrequency);
|
|
|
if (firstDigit === null) {
|
|
|
return null;
|
|
|
}
|
|
|
result.unshift(firstDigit);
|
|
|
|
|
|
code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);
|
|
|
if (code === null) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
code = self._decodeCode(code.end, self.CODE_G_START);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
result.push(code.code);
|
|
|
}
|
|
|
|
|
|
return code;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._decode = function () {
|
|
|
var startInfo,
|
|
|
self = this,
|
|
|
code,
|
|
|
result = [],
|
|
|
decodedCodes = [],
|
|
|
resultInfo = {};
|
|
|
|
|
|
startInfo = self._findStart();
|
|
|
if (!startInfo) {
|
|
|
return null;
|
|
|
}
|
|
|
code = {
|
|
|
code: startInfo.code,
|
|
|
start: startInfo.start,
|
|
|
end: startInfo.end
|
|
|
};
|
|
|
decodedCodes.push(code);
|
|
|
code = self._decodePayload(code, result, decodedCodes);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
code = self._findEnd(code.end, false);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
decodedCodes.push(code);
|
|
|
|
|
|
// Checksum
|
|
|
if (!self._checksum(result)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (this.supplements.length > 0) {
|
|
|
var ext = this._decodeExtensions(code.end);
|
|
|
if (!ext) {
|
|
|
return null;
|
|
|
}
|
|
|
var lastCode = ext.decodedCodes[ext.decodedCodes.length - 1],
|
|
|
endInfo = {
|
|
|
start: lastCode.start + ((lastCode.end - lastCode.start) / 2 | 0),
|
|
|
end: lastCode.end
|
|
|
};
|
|
|
if (!self._verifyTrailingWhitespace(endInfo)) {
|
|
|
return null;
|
|
|
}
|
|
|
resultInfo = {
|
|
|
supplement: ext,
|
|
|
code: result.join("") + ext.code
|
|
|
};
|
|
|
}
|
|
|
|
|
|
return _extends({
|
|
|
code: result.join(""),
|
|
|
start: startInfo.start,
|
|
|
end: code.end,
|
|
|
codeset: "",
|
|
|
startInfo: startInfo,
|
|
|
decodedCodes: decodedCodes
|
|
|
}, resultInfo);
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._decodeExtensions = function (offset) {
|
|
|
var i,
|
|
|
start = this._nextSet(this._row, offset),
|
|
|
startInfo = this._findPattern(this.EXTENSION_START_PATTERN, start, false, false),
|
|
|
result;
|
|
|
|
|
|
if (startInfo === null) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < this.supplements.length; i++) {
|
|
|
result = this.supplements[i].decode(this._row, startInfo.end);
|
|
|
if (result !== null) {
|
|
|
return {
|
|
|
code: result.code,
|
|
|
start: start,
|
|
|
startInfo: startInfo,
|
|
|
end: result.end,
|
|
|
codeset: "",
|
|
|
decodedCodes: result.decodedCodes
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
EANReader.prototype._checksum = function (result) {
|
|
|
var sum = 0,
|
|
|
i;
|
|
|
|
|
|
for (i = result.length - 2; i >= 0; i -= 2) {
|
|
|
sum += result[i];
|
|
|
}
|
|
|
sum *= 3;
|
|
|
for (i = result.length - 1; i >= 0; i -= 2) {
|
|
|
sum += result[i];
|
|
|
}
|
|
|
return sum % 10 === 0;
|
|
|
};
|
|
|
|
|
|
EANReader.CONFIG_KEYS = {
|
|
|
supplements: {
|
|
|
'type': 'arrayOf(string)',
|
|
|
'default': [],
|
|
|
'description': 'Allowed extensions to be decoded (2 and/or 5)'
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = EANReader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 6 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Symbol = __webpack_require__(12),
|
|
|
getRawTag = __webpack_require__(150),
|
|
|
objectToString = __webpack_require__(181);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var nullTag = '[object Null]',
|
|
|
undefinedTag = '[object Undefined]';
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `getTag` without fallbacks for buggy environments.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to query.
|
|
|
* @returns {string} Returns the `toStringTag`.
|
|
|
*/
|
|
|
function baseGetTag(value) {
|
|
|
if (value == null) {
|
|
|
return value === undefined ? undefinedTag : nullTag;
|
|
|
}
|
|
|
return (symToStringTag && symToStringTag in Object(value))
|
|
|
? getRawTag(value)
|
|
|
: objectToString(value);
|
|
|
}
|
|
|
|
|
|
module.exports = baseGetTag;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 7 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isArray = __webpack_require__(2),
|
|
|
isKey = __webpack_require__(163),
|
|
|
stringToPath = __webpack_require__(190),
|
|
|
toString = __webpack_require__(201);
|
|
|
|
|
|
/**
|
|
|
* Casts `value` to a path array if it's not one.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to inspect.
|
|
|
* @param {Object} [object] The object to query keys on.
|
|
|
* @returns {Array} Returns the cast property path array.
|
|
|
*/
|
|
|
function castPath(value, object) {
|
|
|
if (isArray(value)) {
|
|
|
return value;
|
|
|
}
|
|
|
return isKey(value, object) ? [value] : stringToPath(toString(value));
|
|
|
}
|
|
|
|
|
|
module.exports = castPath;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 8 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assignValue = __webpack_require__(29),
|
|
|
baseAssignValue = __webpack_require__(30);
|
|
|
|
|
|
/**
|
|
|
* Copies properties of `source` to `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} source The object to copy properties from.
|
|
|
* @param {Array} props The property identifiers to copy.
|
|
|
* @param {Object} [object={}] The object to copy properties to.
|
|
|
* @param {Function} [customizer] The function to customize copied values.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
function copyObject(source, props, object, customizer) {
|
|
|
var isNew = !object;
|
|
|
object || (object = {});
|
|
|
|
|
|
var index = -1,
|
|
|
length = props.length;
|
|
|
|
|
|
while (++index < length) {
|
|
|
var key = props[index];
|
|
|
|
|
|
var newValue = customizer
|
|
|
? customizer(object[key], source[key], key, object, source)
|
|
|
: undefined;
|
|
|
|
|
|
if (newValue === undefined) {
|
|
|
newValue = source[key];
|
|
|
}
|
|
|
if (isNew) {
|
|
|
baseAssignValue(object, key, newValue);
|
|
|
} else {
|
|
|
assignValue(object, key, newValue);
|
|
|
}
|
|
|
}
|
|
|
return object;
|
|
|
}
|
|
|
|
|
|
module.exports = copyObject;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 9 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is object-like. A value is object-like if it's not `null`
|
|
|
* and has a `typeof` result of "object".
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isObjectLike({});
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isObjectLike([1, 2, 3]);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isObjectLike(_.noop);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isObjectLike(null);
|
|
|
* // => false
|
|
|
*/
|
|
|
function isObjectLike(value) {
|
|
|
return value != null && typeof value == 'object';
|
|
|
}
|
|
|
|
|
|
module.exports = isObjectLike;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 10 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
function BarcodeReader(config, supplements) {
|
|
|
this._row = [];
|
|
|
this.config = config || {};
|
|
|
this.supplements = supplements;
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
BarcodeReader.prototype._nextUnset = function (line, start) {
|
|
|
var i;
|
|
|
|
|
|
if (start === undefined) {
|
|
|
start = 0;
|
|
|
}
|
|
|
for (i = start; i < line.length; i++) {
|
|
|
if (!line[i]) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return line.length;
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype._matchPattern = function (counter, code, maxSingleError) {
|
|
|
var i,
|
|
|
error = 0,
|
|
|
singleError = 0,
|
|
|
sum = 0,
|
|
|
modulo = 0,
|
|
|
barWidth,
|
|
|
count,
|
|
|
scaled;
|
|
|
|
|
|
maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;
|
|
|
|
|
|
for (i = 0; i < counter.length; i++) {
|
|
|
sum += counter[i];
|
|
|
modulo += code[i];
|
|
|
}
|
|
|
if (sum < modulo) {
|
|
|
return Number.MAX_VALUE;
|
|
|
}
|
|
|
barWidth = sum / modulo;
|
|
|
maxSingleError *= barWidth;
|
|
|
|
|
|
for (i = 0; i < counter.length; i++) {
|
|
|
count = counter[i];
|
|
|
scaled = code[i] * barWidth;
|
|
|
singleError = Math.abs(count - scaled) / scaled;
|
|
|
if (singleError > maxSingleError) {
|
|
|
return Number.MAX_VALUE;
|
|
|
}
|
|
|
error += singleError;
|
|
|
}
|
|
|
return error / modulo;
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype._nextSet = function (line, offset) {
|
|
|
var i;
|
|
|
|
|
|
offset = offset || 0;
|
|
|
for (i = offset; i < line.length; i++) {
|
|
|
if (line[i]) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return line.length;
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype._correctBars = function (counter, correction, indices) {
|
|
|
var length = indices.length,
|
|
|
tmp = 0;
|
|
|
while (length--) {
|
|
|
tmp = counter[indices[length]] * (1 - (1 - correction) / 2);
|
|
|
if (tmp > 1) {
|
|
|
counter[indices[length]] = tmp;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype._matchTrace = function (cmpCounter, epsilon) {
|
|
|
var counter = [],
|
|
|
i,
|
|
|
self = this,
|
|
|
offset = self._nextSet(self._row),
|
|
|
isWhite = !self._row[offset],
|
|
|
counterPos = 0,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: 0
|
|
|
},
|
|
|
error;
|
|
|
|
|
|
if (cmpCounter) {
|
|
|
for (i = 0; i < cmpCounter.length; i++) {
|
|
|
counter.push(0);
|
|
|
}
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
error = self._matchPattern(counter, cmpCounter);
|
|
|
|
|
|
if (error < epsilon) {
|
|
|
bestMatch.start = i - offset;
|
|
|
bestMatch.end = i;
|
|
|
bestMatch.counter = counter;
|
|
|
return bestMatch;
|
|
|
} else {
|
|
|
return null;
|
|
|
}
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
counter.push(0);
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
counter.push(0);
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// if cmpCounter was not given
|
|
|
bestMatch.start = offset;
|
|
|
bestMatch.end = self._row.length - 1;
|
|
|
bestMatch.counter = counter;
|
|
|
return bestMatch;
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype.decodePattern = function (pattern) {
|
|
|
var self = this,
|
|
|
result;
|
|
|
|
|
|
self._row = pattern;
|
|
|
result = self._decode();
|
|
|
if (result === null) {
|
|
|
self._row.reverse();
|
|
|
result = self._decode();
|
|
|
if (result) {
|
|
|
result.direction = BarcodeReader.DIRECTION.REVERSE;
|
|
|
result.start = self._row.length - result.start;
|
|
|
result.end = self._row.length - result.end;
|
|
|
}
|
|
|
} else {
|
|
|
result.direction = BarcodeReader.DIRECTION.FORWARD;
|
|
|
}
|
|
|
if (result) {
|
|
|
result.format = self.FORMAT;
|
|
|
}
|
|
|
return result;
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype._matchRange = function (start, end, value) {
|
|
|
var i;
|
|
|
|
|
|
start = start < 0 ? 0 : start;
|
|
|
for (i = start; i < end; i++) {
|
|
|
if (this._row[i] !== value) {
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
};
|
|
|
|
|
|
BarcodeReader.prototype._fillCounters = function (offset, end, isWhite) {
|
|
|
var self = this,
|
|
|
counterPos = 0,
|
|
|
i,
|
|
|
counters = [];
|
|
|
|
|
|
isWhite = typeof isWhite !== 'undefined' ? isWhite : true;
|
|
|
offset = typeof offset !== 'undefined' ? offset : self._nextUnset(self._row);
|
|
|
end = end || self._row.length;
|
|
|
|
|
|
counters[counterPos] = 0;
|
|
|
for (i = offset; i < end; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counters[counterPos]++;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
counters[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return counters;
|
|
|
};
|
|
|
|
|
|
Object.defineProperty(BarcodeReader.prototype, "FORMAT", {
|
|
|
value: 'unknown',
|
|
|
writeable: false
|
|
|
});
|
|
|
|
|
|
BarcodeReader.DIRECTION = {
|
|
|
FORWARD: 1,
|
|
|
REVERSE: -1
|
|
|
};
|
|
|
|
|
|
BarcodeReader.Exception = {
|
|
|
StartNotFoundException: "Start-Info was not found!",
|
|
|
CodeNotFoundException: "Code could not be found!",
|
|
|
PatternNotFoundException: "Pattern could not be found!"
|
|
|
};
|
|
|
|
|
|
BarcodeReader.CONFIG_KEYS = {};
|
|
|
|
|
|
exports.default = BarcodeReader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 11 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = clone
|
|
|
|
|
|
/**
|
|
|
* Creates a new vec2 initialized with values from an existing vector
|
|
|
*
|
|
|
* @param {vec2} a vector to clone
|
|
|
* @returns {vec2} a new 2D vector
|
|
|
*/
|
|
|
function clone(a) {
|
|
|
var out = new Float32Array(2)
|
|
|
out[0] = a[0]
|
|
|
out[1] = a[1]
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 12 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var root = __webpack_require__(1);
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var Symbol = root.Symbol;
|
|
|
|
|
|
module.exports = Symbol;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 13 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
exports.default = {
|
|
|
init: function init(arr, val) {
|
|
|
var l = arr.length;
|
|
|
while (l--) {
|
|
|
arr[l] = val;
|
|
|
}
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* Shuffles the content of an array
|
|
|
* @return {Array} the array itself shuffled
|
|
|
*/
|
|
|
shuffle: function shuffle(arr) {
|
|
|
var i = arr.length - 1,
|
|
|
j,
|
|
|
x;
|
|
|
for (i; i >= 0; i--) {
|
|
|
j = Math.floor(Math.random() * i);
|
|
|
x = arr[i];
|
|
|
arr[i] = arr[j];
|
|
|
arr[j] = x;
|
|
|
}
|
|
|
return arr;
|
|
|
},
|
|
|
|
|
|
toPointList: function toPointList(arr) {
|
|
|
var i,
|
|
|
j,
|
|
|
row = [],
|
|
|
rows = [];
|
|
|
for (i = 0; i < arr.length; i++) {
|
|
|
row = [];
|
|
|
for (j = 0; j < arr[i].length; j++) {
|
|
|
row[j] = arr[i][j];
|
|
|
}
|
|
|
rows[i] = "[" + row.join(",") + "]";
|
|
|
}
|
|
|
return "[" + rows.join(",\r\n") + "]";
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* returns the elements which's score is bigger than the threshold
|
|
|
* @return {Array} the reduced array
|
|
|
*/
|
|
|
threshold: function threshold(arr, _threshold, scoreFunc) {
|
|
|
var i,
|
|
|
queue = [];
|
|
|
for (i = 0; i < arr.length; i++) {
|
|
|
if (scoreFunc.apply(arr, [arr[i]]) >= _threshold) {
|
|
|
queue.push(arr[i]);
|
|
|
}
|
|
|
}
|
|
|
return queue;
|
|
|
},
|
|
|
|
|
|
maxIndex: function maxIndex(arr) {
|
|
|
var i,
|
|
|
max = 0;
|
|
|
for (i = 0; i < arr.length; i++) {
|
|
|
if (arr[i] > arr[max]) {
|
|
|
max = i;
|
|
|
}
|
|
|
}
|
|
|
return max;
|
|
|
},
|
|
|
|
|
|
max: function max(arr) {
|
|
|
var i,
|
|
|
max = 0;
|
|
|
for (i = 0; i < arr.length; i++) {
|
|
|
if (arr[i] > max) {
|
|
|
max = arr[i];
|
|
|
}
|
|
|
}
|
|
|
return max;
|
|
|
},
|
|
|
|
|
|
sum: function sum(arr) {
|
|
|
var length = arr.length,
|
|
|
sum = 0;
|
|
|
|
|
|
while (length--) {
|
|
|
sum += arr[length];
|
|
|
}
|
|
|
return sum;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 14 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
exports.default = {
|
|
|
drawRect: function drawRect(pos, size, ctx, style) {
|
|
|
ctx.strokeStyle = style.color;
|
|
|
ctx.fillStyle = style.color;
|
|
|
ctx.lineWidth = 1;
|
|
|
ctx.beginPath();
|
|
|
ctx.strokeRect(pos.x, pos.y, size.x, size.y);
|
|
|
},
|
|
|
drawPath: function drawPath(path, def, ctx, style) {
|
|
|
ctx.strokeStyle = style.color;
|
|
|
ctx.fillStyle = style.color;
|
|
|
ctx.lineWidth = style.lineWidth;
|
|
|
ctx.beginPath();
|
|
|
ctx.moveTo(path[0][def.x], path[0][def.y]);
|
|
|
for (var j = 1; j < path.length; j++) {
|
|
|
ctx.lineTo(path[j][def.x], path[j][def.y]);
|
|
|
}
|
|
|
ctx.closePath();
|
|
|
ctx.stroke();
|
|
|
},
|
|
|
drawImage: function drawImage(imageData, size, ctx) {
|
|
|
var canvasData = ctx.getImageData(0, 0, size.x, size.y),
|
|
|
data = canvasData.data,
|
|
|
imageDataPos = imageData.length,
|
|
|
canvasDataPos = data.length,
|
|
|
value;
|
|
|
|
|
|
if (canvasDataPos / imageDataPos !== 4) {
|
|
|
return false;
|
|
|
}
|
|
|
while (imageDataPos--) {
|
|
|
value = imageData[imageDataPos];
|
|
|
data[--canvasDataPos] = 255;
|
|
|
data[--canvasDataPos] = value;
|
|
|
data[--canvasDataPos] = value;
|
|
|
data[--canvasDataPos] = value;
|
|
|
}
|
|
|
ctx.putImageData(canvasData, 0, 0);
|
|
|
return true;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 15 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var listCacheClear = __webpack_require__(166),
|
|
|
listCacheDelete = __webpack_require__(167),
|
|
|
listCacheGet = __webpack_require__(168),
|
|
|
listCacheHas = __webpack_require__(169),
|
|
|
listCacheSet = __webpack_require__(170);
|
|
|
|
|
|
/**
|
|
|
* Creates an list cache object.
|
|
|
*
|
|
|
* @private
|
|
|
* @constructor
|
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
|
|
*/
|
|
|
function ListCache(entries) {
|
|
|
var index = -1,
|
|
|
length = entries == null ? 0 : entries.length;
|
|
|
|
|
|
this.clear();
|
|
|
while (++index < length) {
|
|
|
var entry = entries[index];
|
|
|
this.set(entry[0], entry[1]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Add methods to `ListCache`.
|
|
|
ListCache.prototype.clear = listCacheClear;
|
|
|
ListCache.prototype['delete'] = listCacheDelete;
|
|
|
ListCache.prototype.get = listCacheGet;
|
|
|
ListCache.prototype.has = listCacheHas;
|
|
|
ListCache.prototype.set = listCacheSet;
|
|
|
|
|
|
module.exports = ListCache;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 16 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var eq = __webpack_require__(21);
|
|
|
|
|
|
/**
|
|
|
* Gets the index at which the `key` is found in `array` of key-value pairs.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} array The array to inspect.
|
|
|
* @param {*} key The key to search for.
|
|
|
* @returns {number} Returns the index of the matched value, else `-1`.
|
|
|
*/
|
|
|
function assocIndexOf(array, key) {
|
|
|
var length = array.length;
|
|
|
while (length--) {
|
|
|
if (eq(array[length][0], key)) {
|
|
|
return length;
|
|
|
}
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
module.exports = assocIndexOf;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 17 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isKeyable = __webpack_require__(164);
|
|
|
|
|
|
/**
|
|
|
* Gets the data for `map`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} map The map to query.
|
|
|
* @param {string} key The reference key.
|
|
|
* @returns {*} Returns the map data.
|
|
|
*/
|
|
|
function getMapData(map, key) {
|
|
|
var data = map.__data__;
|
|
|
return isKeyable(key)
|
|
|
? data[typeof key == 'string' ? 'string' : 'hash']
|
|
|
: data.map;
|
|
|
}
|
|
|
|
|
|
module.exports = getMapData;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 18 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
|
|
|
|
/** Used to detect unsigned integer values. */
|
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is a valid array-like index.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
|
|
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
|
|
*/
|
|
|
function isIndex(value, length) {
|
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
|
return !!length &&
|
|
|
(typeof value == 'number' || reIsUint.test(value)) &&
|
|
|
(value > -1 && value % 1 == 0 && value < length);
|
|
|
}
|
|
|
|
|
|
module.exports = isIndex;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 19 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4);
|
|
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
|
var nativeCreate = getNative(Object, 'create');
|
|
|
|
|
|
module.exports = nativeCreate;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 20 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isSymbol = __webpack_require__(38);
|
|
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
|
var INFINITY = 1 / 0;
|
|
|
|
|
|
/**
|
|
|
* Converts `value` to a string key if it's not a string or symbol.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to inspect.
|
|
|
* @returns {string|symbol} Returns the key.
|
|
|
*/
|
|
|
function toKey(value) {
|
|
|
if (typeof value == 'string' || isSymbol(value)) {
|
|
|
return value;
|
|
|
}
|
|
|
var result = (value + '');
|
|
|
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
|
|
|
}
|
|
|
|
|
|
module.exports = toKey;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 21 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Performs a
|
|
|
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
|
|
|
* comparison between two values to determine if they are equivalent.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to compare.
|
|
|
* @param {*} other The other value to compare.
|
|
|
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = { 'a': 1 };
|
|
|
* var other = { 'a': 1 };
|
|
|
*
|
|
|
* _.eq(object, object);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.eq(object, other);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.eq('a', 'a');
|
|
|
* // => true
|
|
|
*
|
|
|
* _.eq('a', Object('a'));
|
|
|
* // => false
|
|
|
*
|
|
|
* _.eq(NaN, NaN);
|
|
|
* // => true
|
|
|
*/
|
|
|
function eq(value, other) {
|
|
|
return value === other || (value !== value && other !== other);
|
|
|
}
|
|
|
|
|
|
module.exports = eq;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 22 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseIsArguments = __webpack_require__(121),
|
|
|
isObjectLike = __webpack_require__(9);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is likely an `arguments` object.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
|
|
|
* else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isArguments(function() { return arguments; }());
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArguments([1, 2, 3]);
|
|
|
* // => false
|
|
|
*/
|
|
|
var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
|
|
|
return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
|
|
|
!propertyIsEnumerable.call(value, 'callee');
|
|
|
};
|
|
|
|
|
|
module.exports = isArguments;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 23 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isFunction = __webpack_require__(36),
|
|
|
isLength = __webpack_require__(37);
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is array-like. A value is considered array-like if it's
|
|
|
* not a function and has a `value.length` that's an integer greater than or
|
|
|
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isArrayLike([1, 2, 3]);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArrayLike(document.body.children);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArrayLike('abc');
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArrayLike(_.noop);
|
|
|
* // => false
|
|
|
*/
|
|
|
function isArrayLike(value) {
|
|
|
return value != null && isLength(value.length) && !isFunction(value);
|
|
|
}
|
|
|
|
|
|
module.exports = isArrayLike;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 24 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayLikeKeys = __webpack_require__(47),
|
|
|
baseKeysIn = __webpack_require__(125),
|
|
|
isArrayLike = __webpack_require__(23);
|
|
|
|
|
|
/**
|
|
|
* Creates an array of the own and inherited enumerable property names of `object`.
|
|
|
*
|
|
|
* **Note:** Non-object values are coerced to objects.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 3.0.0
|
|
|
* @category Object
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names.
|
|
|
* @example
|
|
|
*
|
|
|
* function Foo() {
|
|
|
* this.a = 1;
|
|
|
* this.b = 2;
|
|
|
* }
|
|
|
*
|
|
|
* Foo.prototype.c = 3;
|
|
|
*
|
|
|
* _.keysIn(new Foo);
|
|
|
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
|
|
|
*/
|
|
|
function keysIn(object) {
|
|
|
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
|
|
|
}
|
|
|
|
|
|
module.exports = keysIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 25 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
exports._dimensionsConverters = exports.ERODE = exports.DILATE = exports.Tracer = undefined;
|
|
|
exports.imageRef = imageRef;
|
|
|
exports.computeIntegralImage2 = computeIntegralImage2;
|
|
|
exports.computeIntegralImage = computeIntegralImage;
|
|
|
exports.thresholdImage = thresholdImage;
|
|
|
exports.computeHistogram = computeHistogram;
|
|
|
exports.sharpenLine = sharpenLine;
|
|
|
exports.determineOtsuThreshold = determineOtsuThreshold;
|
|
|
exports.otsuThreshold = otsuThreshold;
|
|
|
exports.computeBinaryImage = computeBinaryImage;
|
|
|
exports.cluster = cluster;
|
|
|
exports.dilate = dilate;
|
|
|
exports.erode = erode;
|
|
|
exports.subtract = subtract;
|
|
|
exports.bitwiseOr = bitwiseOr;
|
|
|
exports.countNonZero = countNonZero;
|
|
|
exports.topGeneric = topGeneric;
|
|
|
exports.grayArrayFromImage = grayArrayFromImage;
|
|
|
exports.grayArrayFromContext = grayArrayFromContext;
|
|
|
exports.grayAndHalfSampleFromCanvasData = grayAndHalfSampleFromCanvasData;
|
|
|
exports.computeGray = computeGray;
|
|
|
exports.loadImageArray = loadImageArray;
|
|
|
exports.halfSample = halfSample;
|
|
|
exports.hsv2rgb = hsv2rgb;
|
|
|
exports._computeDivisors = _computeDivisors;
|
|
|
exports.calculatePatchSize = calculatePatchSize;
|
|
|
exports._parseCSSDimensionValues = _parseCSSDimensionValues;
|
|
|
exports.computeImageArea = computeImageArea;
|
|
|
|
|
|
var _cluster = __webpack_require__(75);
|
|
|
|
|
|
var _cluster2 = _interopRequireDefault(_cluster);
|
|
|
|
|
|
var _array_helper = __webpack_require__(13);
|
|
|
|
|
|
var _array_helper2 = _interopRequireDefault(_array_helper);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var vec2 = {
|
|
|
clone: __webpack_require__(11)
|
|
|
};
|
|
|
var vec3 = {
|
|
|
clone: __webpack_require__(102)
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* @param x x-coordinate
|
|
|
* @param y y-coordinate
|
|
|
* @return ImageReference {x,y} Coordinate
|
|
|
*/
|
|
|
function imageRef(x, y) {
|
|
|
var that = {
|
|
|
x: x,
|
|
|
y: y,
|
|
|
toVec2: function toVec2() {
|
|
|
return vec2.clone([this.x, this.y]);
|
|
|
},
|
|
|
toVec3: function toVec3() {
|
|
|
return vec3.clone([this.x, this.y, 1]);
|
|
|
},
|
|
|
round: function round() {
|
|
|
this.x = this.x > 0.0 ? Math.floor(this.x + 0.5) : Math.floor(this.x - 0.5);
|
|
|
this.y = this.y > 0.0 ? Math.floor(this.y + 0.5) : Math.floor(this.y - 0.5);
|
|
|
return this;
|
|
|
}
|
|
|
};
|
|
|
return that;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Computes an integral image of a given grayscale image.
|
|
|
* @param imageDataContainer {ImageDataContainer} the image to be integrated
|
|
|
*/
|
|
|
function computeIntegralImage2(imageWrapper, integralWrapper) {
|
|
|
var imageData = imageWrapper.data;
|
|
|
var width = imageWrapper.size.x;
|
|
|
var height = imageWrapper.size.y;
|
|
|
var integralImageData = integralWrapper.data;
|
|
|
var sum = 0,
|
|
|
posA = 0,
|
|
|
posB = 0,
|
|
|
posC = 0,
|
|
|
posD = 0,
|
|
|
x,
|
|
|
y;
|
|
|
|
|
|
// sum up first column
|
|
|
posB = width;
|
|
|
sum = 0;
|
|
|
for (y = 1; y < height; y++) {
|
|
|
sum += imageData[posA];
|
|
|
integralImageData[posB] += sum;
|
|
|
posA += width;
|
|
|
posB += width;
|
|
|
}
|
|
|
|
|
|
posA = 0;
|
|
|
posB = 1;
|
|
|
sum = 0;
|
|
|
for (x = 1; x < width; x++) {
|
|
|
sum += imageData[posA];
|
|
|
integralImageData[posB] += sum;
|
|
|
posA++;
|
|
|
posB++;
|
|
|
}
|
|
|
|
|
|
for (y = 1; y < height; y++) {
|
|
|
posA = y * width + 1;
|
|
|
posB = (y - 1) * width + 1;
|
|
|
posC = y * width;
|
|
|
posD = (y - 1) * width;
|
|
|
for (x = 1; x < width; x++) {
|
|
|
integralImageData[posA] += imageData[posA] + integralImageData[posB] + integralImageData[posC] - integralImageData[posD];
|
|
|
posA++;
|
|
|
posB++;
|
|
|
posC++;
|
|
|
posD++;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function computeIntegralImage(imageWrapper, integralWrapper) {
|
|
|
var imageData = imageWrapper.data;
|
|
|
var width = imageWrapper.size.x;
|
|
|
var height = imageWrapper.size.y;
|
|
|
var integralImageData = integralWrapper.data;
|
|
|
var sum = 0;
|
|
|
|
|
|
// sum up first row
|
|
|
for (var i = 0; i < width; i++) {
|
|
|
sum += imageData[i];
|
|
|
integralImageData[i] = sum;
|
|
|
}
|
|
|
|
|
|
for (var v = 1; v < height; v++) {
|
|
|
sum = 0;
|
|
|
for (var u = 0; u < width; u++) {
|
|
|
sum += imageData[v * width + u];
|
|
|
integralImageData[v * width + u] = sum + integralImageData[(v - 1) * width + u];
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function thresholdImage(imageWrapper, threshold, targetWrapper) {
|
|
|
if (!targetWrapper) {
|
|
|
targetWrapper = imageWrapper;
|
|
|
}
|
|
|
var imageData = imageWrapper.data,
|
|
|
length = imageData.length,
|
|
|
targetData = targetWrapper.data;
|
|
|
|
|
|
while (length--) {
|
|
|
targetData[length] = imageData[length] < threshold ? 1 : 0;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function computeHistogram(imageWrapper, bitsPerPixel) {
|
|
|
if (!bitsPerPixel) {
|
|
|
bitsPerPixel = 8;
|
|
|
}
|
|
|
var imageData = imageWrapper.data,
|
|
|
length = imageData.length,
|
|
|
bitShift = 8 - bitsPerPixel,
|
|
|
bucketCnt = 1 << bitsPerPixel,
|
|
|
hist = new Int32Array(bucketCnt);
|
|
|
|
|
|
while (length--) {
|
|
|
hist[imageData[length] >> bitShift]++;
|
|
|
}
|
|
|
return hist;
|
|
|
};
|
|
|
|
|
|
function sharpenLine(line) {
|
|
|
var i,
|
|
|
length = line.length,
|
|
|
left = line[0],
|
|
|
center = line[1],
|
|
|
right;
|
|
|
|
|
|
for (i = 1; i < length - 1; i++) {
|
|
|
right = line[i + 1];
|
|
|
// -1 4 -1 kernel
|
|
|
line[i - 1] = center * 2 - left - right & 255;
|
|
|
left = center;
|
|
|
center = right;
|
|
|
}
|
|
|
return line;
|
|
|
};
|
|
|
|
|
|
function determineOtsuThreshold(imageWrapper, bitsPerPixel) {
|
|
|
if (!bitsPerPixel) {
|
|
|
bitsPerPixel = 8;
|
|
|
}
|
|
|
var hist,
|
|
|
threshold,
|
|
|
bitShift = 8 - bitsPerPixel;
|
|
|
|
|
|
function px(init, end) {
|
|
|
var sum = 0,
|
|
|
i;
|
|
|
for (i = init; i <= end; i++) {
|
|
|
sum += hist[i];
|
|
|
}
|
|
|
return sum;
|
|
|
}
|
|
|
|
|
|
function mx(init, end) {
|
|
|
var i,
|
|
|
sum = 0;
|
|
|
|
|
|
for (i = init; i <= end; i++) {
|
|
|
sum += i * hist[i];
|
|
|
}
|
|
|
|
|
|
return sum;
|
|
|
}
|
|
|
|
|
|
function determineThreshold() {
|
|
|
var vet = [0],
|
|
|
p1,
|
|
|
p2,
|
|
|
p12,
|
|
|
k,
|
|
|
m1,
|
|
|
m2,
|
|
|
m12,
|
|
|
max = (1 << bitsPerPixel) - 1;
|
|
|
|
|
|
hist = computeHistogram(imageWrapper, bitsPerPixel);
|
|
|
for (k = 1; k < max; k++) {
|
|
|
p1 = px(0, k);
|
|
|
p2 = px(k + 1, max);
|
|
|
p12 = p1 * p2;
|
|
|
if (p12 === 0) {
|
|
|
p12 = 1;
|
|
|
}
|
|
|
m1 = mx(0, k) * p2;
|
|
|
m2 = mx(k + 1, max) * p1;
|
|
|
m12 = m1 - m2;
|
|
|
vet[k] = m12 * m12 / p12;
|
|
|
}
|
|
|
return _array_helper2.default.maxIndex(vet);
|
|
|
}
|
|
|
|
|
|
threshold = determineThreshold();
|
|
|
return threshold << bitShift;
|
|
|
};
|
|
|
|
|
|
function otsuThreshold(imageWrapper, targetWrapper) {
|
|
|
var threshold = determineOtsuThreshold(imageWrapper);
|
|
|
|
|
|
thresholdImage(imageWrapper, threshold, targetWrapper);
|
|
|
return threshold;
|
|
|
};
|
|
|
|
|
|
// local thresholding
|
|
|
function computeBinaryImage(imageWrapper, integralWrapper, targetWrapper) {
|
|
|
computeIntegralImage(imageWrapper, integralWrapper);
|
|
|
|
|
|
if (!targetWrapper) {
|
|
|
targetWrapper = imageWrapper;
|
|
|
}
|
|
|
var imageData = imageWrapper.data;
|
|
|
var targetData = targetWrapper.data;
|
|
|
var width = imageWrapper.size.x;
|
|
|
var height = imageWrapper.size.y;
|
|
|
var integralImageData = integralWrapper.data;
|
|
|
var sum = 0,
|
|
|
v,
|
|
|
u,
|
|
|
kernel = 3,
|
|
|
A,
|
|
|
B,
|
|
|
C,
|
|
|
D,
|
|
|
avg,
|
|
|
size = (kernel * 2 + 1) * (kernel * 2 + 1);
|
|
|
|
|
|
// clear out top & bottom-border
|
|
|
for (v = 0; v <= kernel; v++) {
|
|
|
for (u = 0; u < width; u++) {
|
|
|
targetData[v * width + u] = 0;
|
|
|
targetData[(height - 1 - v) * width + u] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// clear out left & right border
|
|
|
for (v = kernel; v < height - kernel; v++) {
|
|
|
for (u = 0; u <= kernel; u++) {
|
|
|
targetData[v * width + u] = 0;
|
|
|
targetData[v * width + (width - 1 - u)] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (v = kernel + 1; v < height - kernel - 1; v++) {
|
|
|
for (u = kernel + 1; u < width - kernel; u++) {
|
|
|
A = integralImageData[(v - kernel - 1) * width + (u - kernel - 1)];
|
|
|
B = integralImageData[(v - kernel - 1) * width + (u + kernel)];
|
|
|
C = integralImageData[(v + kernel) * width + (u - kernel - 1)];
|
|
|
D = integralImageData[(v + kernel) * width + (u + kernel)];
|
|
|
sum = D - C - B + A;
|
|
|
avg = sum / size;
|
|
|
targetData[v * width + u] = imageData[v * width + u] > avg + 5 ? 0 : 1;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function cluster(points, threshold, property) {
|
|
|
var i,
|
|
|
k,
|
|
|
cluster,
|
|
|
point,
|
|
|
clusters = [];
|
|
|
|
|
|
if (!property) {
|
|
|
property = "rad";
|
|
|
}
|
|
|
|
|
|
function addToCluster(newPoint) {
|
|
|
var found = false;
|
|
|
for (k = 0; k < clusters.length; k++) {
|
|
|
cluster = clusters[k];
|
|
|
if (cluster.fits(newPoint)) {
|
|
|
cluster.add(newPoint);
|
|
|
found = true;
|
|
|
}
|
|
|
}
|
|
|
return found;
|
|
|
}
|
|
|
|
|
|
// iterate over each cloud
|
|
|
for (i = 0; i < points.length; i++) {
|
|
|
point = _cluster2.default.createPoint(points[i], i, property);
|
|
|
if (!addToCluster(point)) {
|
|
|
clusters.push(_cluster2.default.create(point, threshold));
|
|
|
}
|
|
|
}
|
|
|
return clusters;
|
|
|
};
|
|
|
|
|
|
var Tracer = exports.Tracer = {
|
|
|
trace: function trace(points, vec) {
|
|
|
var iteration,
|
|
|
maxIterations = 10,
|
|
|
top = [],
|
|
|
result = [],
|
|
|
centerPos = 0,
|
|
|
currentPos = 0;
|
|
|
|
|
|
function trace(idx, forward) {
|
|
|
var from,
|
|
|
to,
|
|
|
toIdx,
|
|
|
predictedPos,
|
|
|
thresholdX = 1,
|
|
|
thresholdY = Math.abs(vec[1] / 10),
|
|
|
found = false;
|
|
|
|
|
|
function match(pos, predicted) {
|
|
|
if (pos.x > predicted.x - thresholdX && pos.x < predicted.x + thresholdX && pos.y > predicted.y - thresholdY && pos.y < predicted.y + thresholdY) {
|
|
|
return true;
|
|
|
} else {
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// check if the next index is within the vec specifications
|
|
|
// if not, check as long as the threshold is met
|
|
|
|
|
|
from = points[idx];
|
|
|
if (forward) {
|
|
|
predictedPos = {
|
|
|
x: from.x + vec[0],
|
|
|
y: from.y + vec[1]
|
|
|
};
|
|
|
} else {
|
|
|
predictedPos = {
|
|
|
x: from.x - vec[0],
|
|
|
y: from.y - vec[1]
|
|
|
};
|
|
|
}
|
|
|
|
|
|
toIdx = forward ? idx + 1 : idx - 1;
|
|
|
to = points[toIdx];
|
|
|
while (to && (found = match(to, predictedPos)) !== true && Math.abs(to.y - from.y) < vec[1]) {
|
|
|
toIdx = forward ? toIdx + 1 : toIdx - 1;
|
|
|
to = points[toIdx];
|
|
|
}
|
|
|
|
|
|
return found ? toIdx : null;
|
|
|
}
|
|
|
|
|
|
for (iteration = 0; iteration < maxIterations; iteration++) {
|
|
|
// randomly select point to start with
|
|
|
centerPos = Math.floor(Math.random() * points.length);
|
|
|
|
|
|
// trace forward
|
|
|
top = [];
|
|
|
currentPos = centerPos;
|
|
|
top.push(points[currentPos]);
|
|
|
while ((currentPos = trace(currentPos, true)) !== null) {
|
|
|
top.push(points[currentPos]);
|
|
|
}
|
|
|
if (centerPos > 0) {
|
|
|
currentPos = centerPos;
|
|
|
while ((currentPos = trace(currentPos, false)) !== null) {
|
|
|
top.push(points[currentPos]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (top.length > result.length) {
|
|
|
result = top;
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
var DILATE = exports.DILATE = 1;
|
|
|
var ERODE = exports.ERODE = 2;
|
|
|
|
|
|
function dilate(inImageWrapper, outImageWrapper) {
|
|
|
var v,
|
|
|
u,
|
|
|
inImageData = inImageWrapper.data,
|
|
|
outImageData = outImageWrapper.data,
|
|
|
height = inImageWrapper.size.y,
|
|
|
width = inImageWrapper.size.x,
|
|
|
sum,
|
|
|
yStart1,
|
|
|
yStart2,
|
|
|
xStart1,
|
|
|
xStart2;
|
|
|
|
|
|
for (v = 1; v < height - 1; v++) {
|
|
|
for (u = 1; u < width - 1; u++) {
|
|
|
yStart1 = v - 1;
|
|
|
yStart2 = v + 1;
|
|
|
xStart1 = u - 1;
|
|
|
xStart2 = u + 1;
|
|
|
sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] + inImageData[v * width + u] + inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];
|
|
|
outImageData[v * width + u] = sum > 0 ? 1 : 0;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function erode(inImageWrapper, outImageWrapper) {
|
|
|
var v,
|
|
|
u,
|
|
|
inImageData = inImageWrapper.data,
|
|
|
outImageData = outImageWrapper.data,
|
|
|
height = inImageWrapper.size.y,
|
|
|
width = inImageWrapper.size.x,
|
|
|
sum,
|
|
|
yStart1,
|
|
|
yStart2,
|
|
|
xStart1,
|
|
|
xStart2;
|
|
|
|
|
|
for (v = 1; v < height - 1; v++) {
|
|
|
for (u = 1; u < width - 1; u++) {
|
|
|
yStart1 = v - 1;
|
|
|
yStart2 = v + 1;
|
|
|
xStart1 = u - 1;
|
|
|
xStart2 = u + 1;
|
|
|
sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] + inImageData[v * width + u] + inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];
|
|
|
outImageData[v * width + u] = sum === 5 ? 1 : 0;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function subtract(aImageWrapper, bImageWrapper, resultImageWrapper) {
|
|
|
if (!resultImageWrapper) {
|
|
|
resultImageWrapper = aImageWrapper;
|
|
|
}
|
|
|
var length = aImageWrapper.data.length,
|
|
|
aImageData = aImageWrapper.data,
|
|
|
bImageData = bImageWrapper.data,
|
|
|
cImageData = resultImageWrapper.data;
|
|
|
|
|
|
while (length--) {
|
|
|
cImageData[length] = aImageData[length] - bImageData[length];
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function bitwiseOr(aImageWrapper, bImageWrapper, resultImageWrapper) {
|
|
|
if (!resultImageWrapper) {
|
|
|
resultImageWrapper = aImageWrapper;
|
|
|
}
|
|
|
var length = aImageWrapper.data.length,
|
|
|
aImageData = aImageWrapper.data,
|
|
|
bImageData = bImageWrapper.data,
|
|
|
cImageData = resultImageWrapper.data;
|
|
|
|
|
|
while (length--) {
|
|
|
cImageData[length] = aImageData[length] || bImageData[length];
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function countNonZero(imageWrapper) {
|
|
|
var length = imageWrapper.data.length,
|
|
|
data = imageWrapper.data,
|
|
|
sum = 0;
|
|
|
|
|
|
while (length--) {
|
|
|
sum += data[length];
|
|
|
}
|
|
|
return sum;
|
|
|
};
|
|
|
|
|
|
function topGeneric(list, top, scoreFunc) {
|
|
|
var i,
|
|
|
minIdx = 0,
|
|
|
min = 0,
|
|
|
queue = [],
|
|
|
score,
|
|
|
hit,
|
|
|
pos;
|
|
|
|
|
|
for (i = 0; i < top; i++) {
|
|
|
queue[i] = {
|
|
|
score: 0,
|
|
|
item: null
|
|
|
};
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < list.length; i++) {
|
|
|
score = scoreFunc.apply(this, [list[i]]);
|
|
|
if (score > min) {
|
|
|
hit = queue[minIdx];
|
|
|
hit.score = score;
|
|
|
hit.item = list[i];
|
|
|
min = Number.MAX_VALUE;
|
|
|
for (pos = 0; pos < top; pos++) {
|
|
|
if (queue[pos].score < min) {
|
|
|
min = queue[pos].score;
|
|
|
minIdx = pos;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return queue;
|
|
|
};
|
|
|
|
|
|
function grayArrayFromImage(htmlImage, offsetX, ctx, array) {
|
|
|
ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height);
|
|
|
var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data;
|
|
|
computeGray(ctxData, array);
|
|
|
};
|
|
|
|
|
|
function grayArrayFromContext(ctx, size, offset, array) {
|
|
|
var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data;
|
|
|
computeGray(ctxData, array);
|
|
|
};
|
|
|
|
|
|
function grayAndHalfSampleFromCanvasData(canvasData, size, outArray) {
|
|
|
var topRowIdx = 0;
|
|
|
var bottomRowIdx = size.x;
|
|
|
var endIdx = Math.floor(canvasData.length / 4);
|
|
|
var outWidth = size.x / 2;
|
|
|
var outImgIdx = 0;
|
|
|
var inWidth = size.x;
|
|
|
var i;
|
|
|
|
|
|
while (bottomRowIdx < endIdx) {
|
|
|
for (i = 0; i < outWidth; i++) {
|
|
|
outArray[outImgIdx] = Math.floor((0.299 * canvasData[topRowIdx * 4 + 0] + 0.587 * canvasData[topRowIdx * 4 + 1] + 0.114 * canvasData[topRowIdx * 4 + 2] + (0.299 * canvasData[(topRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(topRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(topRowIdx + 1) * 4 + 2]) + (0.299 * canvasData[bottomRowIdx * 4 + 0] + 0.587 * canvasData[bottomRowIdx * 4 + 1] + 0.114 * canvasData[bottomRowIdx * 4 + 2]) + (0.299 * canvasData[(bottomRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(bottomRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(bottomRowIdx + 1) * 4 + 2])) / 4);
|
|
|
outImgIdx++;
|
|
|
topRowIdx = topRowIdx + 2;
|
|
|
bottomRowIdx = bottomRowIdx + 2;
|
|
|
}
|
|
|
topRowIdx = topRowIdx + inWidth;
|
|
|
bottomRowIdx = bottomRowIdx + inWidth;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function computeGray(imageData, outArray, config) {
|
|
|
var l = imageData.length / 4 | 0,
|
|
|
i,
|
|
|
singleChannel = config && config.singleChannel === true;
|
|
|
|
|
|
if (singleChannel) {
|
|
|
for (i = 0; i < l; i++) {
|
|
|
outArray[i] = imageData[i * 4 + 0];
|
|
|
}
|
|
|
} else {
|
|
|
for (i = 0; i < l; i++) {
|
|
|
outArray[i] = Math.floor(0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2]);
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function loadImageArray(src, callback, canvas) {
|
|
|
if (!canvas) {
|
|
|
canvas = document.createElement('canvas');
|
|
|
}
|
|
|
var img = new Image();
|
|
|
img.callback = callback;
|
|
|
img.onload = function () {
|
|
|
canvas.width = this.width;
|
|
|
canvas.height = this.height;
|
|
|
var ctx = canvas.getContext('2d');
|
|
|
ctx.drawImage(this, 0, 0);
|
|
|
var array = new Uint8Array(this.width * this.height);
|
|
|
ctx.drawImage(this, 0, 0);
|
|
|
var data = ctx.getImageData(0, 0, this.width, this.height).data;
|
|
|
computeGray(data, array);
|
|
|
this.callback(array, {
|
|
|
x: this.width,
|
|
|
y: this.height
|
|
|
}, this);
|
|
|
};
|
|
|
img.src = src;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* @param inImg {ImageWrapper} input image to be sampled
|
|
|
* @param outImg {ImageWrapper} to be stored in
|
|
|
*/
|
|
|
function halfSample(inImgWrapper, outImgWrapper) {
|
|
|
var inImg = inImgWrapper.data;
|
|
|
var inWidth = inImgWrapper.size.x;
|
|
|
var outImg = outImgWrapper.data;
|
|
|
var topRowIdx = 0;
|
|
|
var bottomRowIdx = inWidth;
|
|
|
var endIdx = inImg.length;
|
|
|
var outWidth = inWidth / 2;
|
|
|
var outImgIdx = 0;
|
|
|
while (bottomRowIdx < endIdx) {
|
|
|
for (var i = 0; i < outWidth; i++) {
|
|
|
outImg[outImgIdx] = Math.floor((inImg[topRowIdx] + inImg[topRowIdx + 1] + inImg[bottomRowIdx] + inImg[bottomRowIdx + 1]) / 4);
|
|
|
outImgIdx++;
|
|
|
topRowIdx = topRowIdx + 2;
|
|
|
bottomRowIdx = bottomRowIdx + 2;
|
|
|
}
|
|
|
topRowIdx = topRowIdx + inWidth;
|
|
|
bottomRowIdx = bottomRowIdx + inWidth;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function hsv2rgb(hsv, rgb) {
|
|
|
var h = hsv[0],
|
|
|
s = hsv[1],
|
|
|
v = hsv[2],
|
|
|
c = v * s,
|
|
|
x = c * (1 - Math.abs(h / 60 % 2 - 1)),
|
|
|
m = v - c,
|
|
|
r = 0,
|
|
|
g = 0,
|
|
|
b = 0;
|
|
|
|
|
|
rgb = rgb || [0, 0, 0];
|
|
|
|
|
|
if (h < 60) {
|
|
|
r = c;
|
|
|
g = x;
|
|
|
} else if (h < 120) {
|
|
|
r = x;
|
|
|
g = c;
|
|
|
} else if (h < 180) {
|
|
|
g = c;
|
|
|
b = x;
|
|
|
} else if (h < 240) {
|
|
|
g = x;
|
|
|
b = c;
|
|
|
} else if (h < 300) {
|
|
|
r = x;
|
|
|
b = c;
|
|
|
} else if (h < 360) {
|
|
|
r = c;
|
|
|
b = x;
|
|
|
}
|
|
|
rgb[0] = (r + m) * 255 | 0;
|
|
|
rgb[1] = (g + m) * 255 | 0;
|
|
|
rgb[2] = (b + m) * 255 | 0;
|
|
|
return rgb;
|
|
|
};
|
|
|
|
|
|
function _computeDivisors(n) {
|
|
|
var largeDivisors = [],
|
|
|
divisors = [],
|
|
|
i;
|
|
|
|
|
|
for (i = 1; i < Math.sqrt(n) + 1; i++) {
|
|
|
if (n % i === 0) {
|
|
|
divisors.push(i);
|
|
|
if (i !== n / i) {
|
|
|
largeDivisors.unshift(Math.floor(n / i));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return divisors.concat(largeDivisors);
|
|
|
};
|
|
|
|
|
|
function _computeIntersection(arr1, arr2) {
|
|
|
var i = 0,
|
|
|
j = 0,
|
|
|
result = [];
|
|
|
|
|
|
while (i < arr1.length && j < arr2.length) {
|
|
|
if (arr1[i] === arr2[j]) {
|
|
|
result.push(arr1[i]);
|
|
|
i++;
|
|
|
j++;
|
|
|
} else if (arr1[i] > arr2[j]) {
|
|
|
j++;
|
|
|
} else {
|
|
|
i++;
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
};
|
|
|
|
|
|
function calculatePatchSize(patchSize, imgSize) {
|
|
|
var divisorsX = _computeDivisors(imgSize.x),
|
|
|
divisorsY = _computeDivisors(imgSize.y),
|
|
|
wideSide = Math.max(imgSize.x, imgSize.y),
|
|
|
common = _computeIntersection(divisorsX, divisorsY),
|
|
|
nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80],
|
|
|
nrOfPatchesMap = {
|
|
|
"x-small": 5,
|
|
|
"small": 4,
|
|
|
"medium": 3,
|
|
|
"large": 2,
|
|
|
"x-large": 1
|
|
|
},
|
|
|
nrOfPatchesIdx = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium,
|
|
|
nrOfPatches = nrOfPatchesList[nrOfPatchesIdx],
|
|
|
desiredPatchSize = Math.floor(wideSide / nrOfPatches),
|
|
|
optimalPatchSize;
|
|
|
|
|
|
function findPatchSizeForDivisors(divisors) {
|
|
|
var i = 0,
|
|
|
found = divisors[Math.floor(divisors.length / 2)];
|
|
|
|
|
|
while (i < divisors.length - 1 && divisors[i] < desiredPatchSize) {
|
|
|
i++;
|
|
|
}
|
|
|
if (i > 0) {
|
|
|
if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {
|
|
|
found = divisors[i - 1];
|
|
|
} else {
|
|
|
found = divisors[i];
|
|
|
}
|
|
|
}
|
|
|
if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIdx + 1] / nrOfPatchesList[nrOfPatchesIdx] && desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIdx - 1] / nrOfPatchesList[nrOfPatchesIdx]) {
|
|
|
return { x: found, y: found };
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
optimalPatchSize = findPatchSizeForDivisors(common);
|
|
|
if (!optimalPatchSize) {
|
|
|
optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(wideSide));
|
|
|
if (!optimalPatchSize) {
|
|
|
optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(desiredPatchSize * nrOfPatches));
|
|
|
}
|
|
|
}
|
|
|
return optimalPatchSize;
|
|
|
};
|
|
|
|
|
|
function _parseCSSDimensionValues(value) {
|
|
|
var dimension = {
|
|
|
value: parseFloat(value),
|
|
|
unit: value.indexOf("%") === value.length - 1 ? "%" : "%"
|
|
|
};
|
|
|
|
|
|
return dimension;
|
|
|
};
|
|
|
|
|
|
var _dimensionsConverters = exports._dimensionsConverters = {
|
|
|
top: function top(dimension, context) {
|
|
|
if (dimension.unit === "%") {
|
|
|
return Math.floor(context.height * (dimension.value / 100));
|
|
|
}
|
|
|
},
|
|
|
right: function right(dimension, context) {
|
|
|
if (dimension.unit === "%") {
|
|
|
return Math.floor(context.width - context.width * (dimension.value / 100));
|
|
|
}
|
|
|
},
|
|
|
bottom: function bottom(dimension, context) {
|
|
|
if (dimension.unit === "%") {
|
|
|
return Math.floor(context.height - context.height * (dimension.value / 100));
|
|
|
}
|
|
|
},
|
|
|
left: function left(dimension, context) {
|
|
|
if (dimension.unit === "%") {
|
|
|
return Math.floor(context.width * (dimension.value / 100));
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function computeImageArea(inputWidth, inputHeight, area) {
|
|
|
var context = { width: inputWidth, height: inputHeight };
|
|
|
|
|
|
var parsedArea = Object.keys(area).reduce(function (result, key) {
|
|
|
var value = area[key],
|
|
|
parsed = _parseCSSDimensionValues(value),
|
|
|
calculated = _dimensionsConverters[key](parsed, context);
|
|
|
|
|
|
result[key] = calculated;
|
|
|
return result;
|
|
|
}, {});
|
|
|
|
|
|
return {
|
|
|
sx: parsedArea.left,
|
|
|
sy: parsedArea.top,
|
|
|
sw: parsedArea.right - parsedArea.left,
|
|
|
sh: parsedArea.bottom - parsedArea.top
|
|
|
};
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 26 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _subImage = __webpack_require__(78);
|
|
|
|
|
|
var _subImage2 = _interopRequireDefault(_subImage);
|
|
|
|
|
|
var _cv_utils = __webpack_require__(25);
|
|
|
|
|
|
var _array_helper = __webpack_require__(13);
|
|
|
|
|
|
var _array_helper2 = _interopRequireDefault(_array_helper);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var vec2 = {
|
|
|
clone: __webpack_require__(11)
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Represents a basic image combining the data and size.
|
|
|
* In addition, some methods for manipulation are contained.
|
|
|
* @param size {x,y} The size of the image in pixel
|
|
|
* @param data {Array} If given, a flat array containing the pixel data
|
|
|
* @param ArrayType {Type} If given, the desired DataType of the Array (may be typed/non-typed)
|
|
|
* @param initialize {Boolean} Indicating if the array should be initialized on creation.
|
|
|
* @returns {ImageWrapper}
|
|
|
*/
|
|
|
function ImageWrapper(size, data, ArrayType, initialize) {
|
|
|
if (!data) {
|
|
|
if (ArrayType) {
|
|
|
this.data = new ArrayType(size.x * size.y);
|
|
|
if (ArrayType === Array && initialize) {
|
|
|
_array_helper2.default.init(this.data, 0);
|
|
|
}
|
|
|
} else {
|
|
|
this.data = new Uint8Array(size.x * size.y);
|
|
|
if (Uint8Array === Array && initialize) {
|
|
|
_array_helper2.default.init(this.data, 0);
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
this.data = data;
|
|
|
}
|
|
|
this.size = size;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* tests if a position is within the image with a given offset
|
|
|
* @param imgRef {x, y} The location to test
|
|
|
* @param border Number the padding value in pixel
|
|
|
* @returns {Boolean} true if location inside the image's border, false otherwise
|
|
|
* @see cvd/image.h
|
|
|
*/
|
|
|
ImageWrapper.prototype.inImageWithBorder = function (imgRef, border) {
|
|
|
return imgRef.x >= border && imgRef.y >= border && imgRef.x < this.size.x - border && imgRef.y < this.size.y - border;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Performs bilinear sampling
|
|
|
* @param inImg Image to extract sample from
|
|
|
* @param x the x-coordinate
|
|
|
* @param y the y-coordinate
|
|
|
* @returns the sampled value
|
|
|
* @see cvd/vision.h
|
|
|
*/
|
|
|
ImageWrapper.sample = function (inImg, x, y) {
|
|
|
var lx = Math.floor(x);
|
|
|
var ly = Math.floor(y);
|
|
|
var w = inImg.size.x;
|
|
|
var base = ly * inImg.size.x + lx;
|
|
|
var a = inImg.data[base + 0];
|
|
|
var b = inImg.data[base + 1];
|
|
|
var c = inImg.data[base + w];
|
|
|
var d = inImg.data[base + w + 1];
|
|
|
var e = a - b;
|
|
|
x -= lx;
|
|
|
y -= ly;
|
|
|
|
|
|
var result = Math.floor(x * (y * (e - c + d) - e) + y * (c - a) + a);
|
|
|
return result;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Initializes a given array. Sets each element to zero.
|
|
|
* @param array {Array} The array to initialize
|
|
|
*/
|
|
|
ImageWrapper.clearArray = function (array) {
|
|
|
var l = array.length;
|
|
|
while (l--) {
|
|
|
array[l] = 0;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Creates a {SubImage} from the current image ({this}).
|
|
|
* @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)
|
|
|
* @param size {ImageRef} The size of the resulting image
|
|
|
* @returns {SubImage} A shared part of the original image
|
|
|
*/
|
|
|
ImageWrapper.prototype.subImage = function (from, size) {
|
|
|
return new _subImage2.default(from, size, this);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Creates an {ImageWrapper) and copies the needed underlying image-data area
|
|
|
* @param imageWrapper {ImageWrapper} The target {ImageWrapper} where the data should be copied
|
|
|
* @param from {ImageRef} The location where to copy from (top-left location)
|
|
|
*/
|
|
|
ImageWrapper.prototype.subImageAsCopy = function (imageWrapper, from) {
|
|
|
var sizeY = imageWrapper.size.y,
|
|
|
sizeX = imageWrapper.size.x;
|
|
|
var x, y;
|
|
|
for (x = 0; x < sizeX; x++) {
|
|
|
for (y = 0; y < sizeY; y++) {
|
|
|
imageWrapper.data[y * sizeX + x] = this.data[(from.y + y) * this.size.x + from.x + x];
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
ImageWrapper.prototype.copyTo = function (imageWrapper) {
|
|
|
var length = this.data.length,
|
|
|
srcData = this.data,
|
|
|
dstData = imageWrapper.data;
|
|
|
|
|
|
while (length--) {
|
|
|
dstData[length] = srcData[length];
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Retrieves a given pixel position from the image
|
|
|
* @param x {Number} The x-position
|
|
|
* @param y {Number} The y-position
|
|
|
* @returns {Number} The grayscale value at the pixel-position
|
|
|
*/
|
|
|
ImageWrapper.prototype.get = function (x, y) {
|
|
|
return this.data[y * this.size.x + x];
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Retrieves a given pixel position from the image
|
|
|
* @param x {Number} The x-position
|
|
|
* @param y {Number} The y-position
|
|
|
* @returns {Number} The grayscale value at the pixel-position
|
|
|
*/
|
|
|
ImageWrapper.prototype.getSafe = function (x, y) {
|
|
|
var i;
|
|
|
|
|
|
if (!this.indexMapping) {
|
|
|
this.indexMapping = {
|
|
|
x: [],
|
|
|
y: []
|
|
|
};
|
|
|
for (i = 0; i < this.size.x; i++) {
|
|
|
this.indexMapping.x[i] = i;
|
|
|
this.indexMapping.x[i + this.size.x] = i;
|
|
|
}
|
|
|
for (i = 0; i < this.size.y; i++) {
|
|
|
this.indexMapping.y[i] = i;
|
|
|
this.indexMapping.y[i + this.size.y] = i;
|
|
|
}
|
|
|
}
|
|
|
return this.data[this.indexMapping.y[y + this.size.y] * this.size.x + this.indexMapping.x[x + this.size.x]];
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Sets a given pixel position in the image
|
|
|
* @param x {Number} The x-position
|
|
|
* @param y {Number} The y-position
|
|
|
* @param value {Number} The grayscale value to set
|
|
|
* @returns {ImageWrapper} The Image itself (for possible chaining)
|
|
|
*/
|
|
|
ImageWrapper.prototype.set = function (x, y, value) {
|
|
|
this.data[y * this.size.x + x] = value;
|
|
|
return this;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Sets the border of the image (1 pixel) to zero
|
|
|
*/
|
|
|
ImageWrapper.prototype.zeroBorder = function () {
|
|
|
var i,
|
|
|
width = this.size.x,
|
|
|
height = this.size.y,
|
|
|
data = this.data;
|
|
|
for (i = 0; i < width; i++) {
|
|
|
data[i] = data[(height - 1) * width + i] = 0;
|
|
|
}
|
|
|
for (i = 1; i < height - 1; i++) {
|
|
|
data[i * width] = data[i * width + (width - 1)] = 0;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Inverts a binary image in place
|
|
|
*/
|
|
|
ImageWrapper.prototype.invert = function () {
|
|
|
var data = this.data,
|
|
|
length = data.length;
|
|
|
|
|
|
while (length--) {
|
|
|
data[length] = data[length] ? 0 : 1;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
ImageWrapper.prototype.convolve = function (kernel) {
|
|
|
var x,
|
|
|
y,
|
|
|
kx,
|
|
|
ky,
|
|
|
kSize = kernel.length / 2 | 0,
|
|
|
accu = 0;
|
|
|
for (y = 0; y < this.size.y; y++) {
|
|
|
for (x = 0; x < this.size.x; x++) {
|
|
|
accu = 0;
|
|
|
for (ky = -kSize; ky <= kSize; ky++) {
|
|
|
for (kx = -kSize; kx <= kSize; kx++) {
|
|
|
accu += kernel[ky + kSize][kx + kSize] * this.getSafe(x + kx, y + ky);
|
|
|
}
|
|
|
}
|
|
|
this.data[y * this.size.x + x] = accu;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
ImageWrapper.prototype.moments = function (labelcount) {
|
|
|
var data = this.data,
|
|
|
x,
|
|
|
y,
|
|
|
height = this.size.y,
|
|
|
width = this.size.x,
|
|
|
val,
|
|
|
ysq,
|
|
|
labelsum = [],
|
|
|
i,
|
|
|
label,
|
|
|
mu11,
|
|
|
mu02,
|
|
|
mu20,
|
|
|
x_,
|
|
|
y_,
|
|
|
tmp,
|
|
|
result = [],
|
|
|
PI = Math.PI,
|
|
|
PI_4 = PI / 4;
|
|
|
|
|
|
if (labelcount <= 0) {
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < labelcount; i++) {
|
|
|
labelsum[i] = {
|
|
|
m00: 0,
|
|
|
m01: 0,
|
|
|
m10: 0,
|
|
|
m11: 0,
|
|
|
m02: 0,
|
|
|
m20: 0,
|
|
|
theta: 0,
|
|
|
rad: 0
|
|
|
};
|
|
|
}
|
|
|
|
|
|
for (y = 0; y < height; y++) {
|
|
|
ysq = y * y;
|
|
|
for (x = 0; x < width; x++) {
|
|
|
val = data[y * width + x];
|
|
|
if (val > 0) {
|
|
|
label = labelsum[val - 1];
|
|
|
label.m00 += 1;
|
|
|
label.m01 += y;
|
|
|
label.m10 += x;
|
|
|
label.m11 += x * y;
|
|
|
label.m02 += ysq;
|
|
|
label.m20 += x * x;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < labelcount; i++) {
|
|
|
label = labelsum[i];
|
|
|
if (!isNaN(label.m00) && label.m00 !== 0) {
|
|
|
x_ = label.m10 / label.m00;
|
|
|
y_ = label.m01 / label.m00;
|
|
|
mu11 = label.m11 / label.m00 - x_ * y_;
|
|
|
mu02 = label.m02 / label.m00 - y_ * y_;
|
|
|
mu20 = label.m20 / label.m00 - x_ * x_;
|
|
|
tmp = (mu02 - mu20) / (2 * mu11);
|
|
|
tmp = 0.5 * Math.atan(tmp) + (mu11 >= 0 ? PI_4 : -PI_4) + PI;
|
|
|
label.theta = (tmp * 180 / PI + 90) % 180 - 90;
|
|
|
if (label.theta < 0) {
|
|
|
label.theta += 180;
|
|
|
}
|
|
|
label.rad = tmp > PI ? tmp - PI : tmp;
|
|
|
label.vec = vec2.clone([Math.cos(tmp), Math.sin(tmp)]);
|
|
|
result.push(label);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Displays the {ImageWrapper} in a given canvas
|
|
|
* @param canvas {Canvas} The canvas element to write to
|
|
|
* @param scale {Number} Scale which is applied to each pixel-value
|
|
|
*/
|
|
|
ImageWrapper.prototype.show = function (canvas, scale) {
|
|
|
var ctx, frame, data, current, pixel, x, y;
|
|
|
|
|
|
if (!scale) {
|
|
|
scale = 1.0;
|
|
|
}
|
|
|
ctx = canvas.getContext('2d');
|
|
|
canvas.width = this.size.x;
|
|
|
canvas.height = this.size.y;
|
|
|
frame = ctx.getImageData(0, 0, canvas.width, canvas.height);
|
|
|
data = frame.data;
|
|
|
current = 0;
|
|
|
for (y = 0; y < this.size.y; y++) {
|
|
|
for (x = 0; x < this.size.x; x++) {
|
|
|
pixel = y * this.size.x + x;
|
|
|
current = this.get(x, y) * scale;
|
|
|
data[pixel * 4 + 0] = current;
|
|
|
data[pixel * 4 + 1] = current;
|
|
|
data[pixel * 4 + 2] = current;
|
|
|
data[pixel * 4 + 3] = 255;
|
|
|
}
|
|
|
}
|
|
|
//frame.data = data;
|
|
|
ctx.putImageData(frame, 0, 0);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Displays the {SubImage} in a given canvas
|
|
|
* @param canvas {Canvas} The canvas element to write to
|
|
|
* @param scale {Number} Scale which is applied to each pixel-value
|
|
|
*/
|
|
|
ImageWrapper.prototype.overlay = function (canvas, scale, from) {
|
|
|
if (!scale || scale < 0 || scale > 360) {
|
|
|
scale = 360;
|
|
|
}
|
|
|
var hsv = [0, 1, 1];
|
|
|
var rgb = [0, 0, 0];
|
|
|
var whiteRgb = [255, 255, 255];
|
|
|
var blackRgb = [0, 0, 0];
|
|
|
var result = [];
|
|
|
var ctx = canvas.getContext('2d');
|
|
|
var frame = ctx.getImageData(from.x, from.y, this.size.x, this.size.y);
|
|
|
var data = frame.data;
|
|
|
var length = this.data.length;
|
|
|
while (length--) {
|
|
|
hsv[0] = this.data[length] * scale;
|
|
|
result = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : (0, _cv_utils.hsv2rgb)(hsv, rgb);
|
|
|
data[length * 4 + 0] = result[0];
|
|
|
data[length * 4 + 1] = result[1];
|
|
|
data[length * 4 + 2] = result[2];
|
|
|
data[length * 4 + 3] = 255;
|
|
|
}
|
|
|
ctx.putImageData(frame, from.x, from.y);
|
|
|
};
|
|
|
|
|
|
exports.default = ImageWrapper;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 27 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4),
|
|
|
root = __webpack_require__(1);
|
|
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
|
var Map = getNative(root, 'Map');
|
|
|
|
|
|
module.exports = Map;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 28 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Appends the elements of `values` to `array`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} array The array to modify.
|
|
|
* @param {Array} values The values to append.
|
|
|
* @returns {Array} Returns `array`.
|
|
|
*/
|
|
|
function arrayPush(array, values) {
|
|
|
var index = -1,
|
|
|
length = values.length,
|
|
|
offset = array.length;
|
|
|
|
|
|
while (++index < length) {
|
|
|
array[offset + index] = values[index];
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
module.exports = arrayPush;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 29 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseAssignValue = __webpack_require__(30),
|
|
|
eq = __webpack_require__(21);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* Assigns `value` to `key` of `object` if the existing value is not equivalent
|
|
|
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
|
|
|
* for equality comparisons.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to modify.
|
|
|
* @param {string} key The key of the property to assign.
|
|
|
* @param {*} value The value to assign.
|
|
|
*/
|
|
|
function assignValue(object, key, value) {
|
|
|
var objValue = object[key];
|
|
|
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
|
|
|
(value === undefined && !(key in object))) {
|
|
|
baseAssignValue(object, key, value);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
module.exports = assignValue;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 30 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var defineProperty = __webpack_require__(56);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `assignValue` and `assignMergeValue` without
|
|
|
* value checks.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to modify.
|
|
|
* @param {string} key The key of the property to assign.
|
|
|
* @param {*} value The value to assign.
|
|
|
*/
|
|
|
function baseAssignValue(object, key, value) {
|
|
|
if (key == '__proto__' && defineProperty) {
|
|
|
defineProperty(object, key, {
|
|
|
'configurable': true,
|
|
|
'enumerable': true,
|
|
|
'value': value,
|
|
|
'writable': true
|
|
|
});
|
|
|
} else {
|
|
|
object[key] = value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
module.exports = baseAssignValue;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 31 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Uint8Array = __webpack_require__(107);
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `arrayBuffer`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {ArrayBuffer} arrayBuffer The array buffer to clone.
|
|
|
* @returns {ArrayBuffer} Returns the cloned array buffer.
|
|
|
*/
|
|
|
function cloneArrayBuffer(arrayBuffer) {
|
|
|
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
|
|
|
new Uint8Array(result).set(new Uint8Array(arrayBuffer));
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = cloneArrayBuffer;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 32 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var overArg = __webpack_require__(62);
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var getPrototype = overArg(Object.getPrototypeOf, Object);
|
|
|
|
|
|
module.exports = getPrototype;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 33 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayFilter = __webpack_require__(113),
|
|
|
stubArray = __webpack_require__(69);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
|
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
|
var nativeGetSymbols = Object.getOwnPropertySymbols;
|
|
|
|
|
|
/**
|
|
|
* Creates an array of the own enumerable symbols of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of symbols.
|
|
|
*/
|
|
|
var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
|
|
|
if (object == null) {
|
|
|
return [];
|
|
|
}
|
|
|
object = Object(object);
|
|
|
return arrayFilter(nativeGetSymbols(object), function(symbol) {
|
|
|
return propertyIsEnumerable.call(object, symbol);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
module.exports = getSymbols;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 34 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is likely a prototype object.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
|
|
|
*/
|
|
|
function isPrototype(value) {
|
|
|
var Ctor = value && value.constructor,
|
|
|
proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
|
|
|
|
|
|
return value === proto;
|
|
|
}
|
|
|
|
|
|
module.exports = isPrototype;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 35 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(1),
|
|
|
stubFalse = __webpack_require__(199);
|
|
|
|
|
|
/** Detect free variable `exports`. */
|
|
|
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
|
|
|
|
|
|
/** Detect free variable `module`. */
|
|
|
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
|
|
|
|
|
|
/** Detect the popular CommonJS extension `module.exports`. */
|
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var Buffer = moduleExports ? root.Buffer : undefined;
|
|
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
|
var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is a buffer.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.3.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isBuffer(new Buffer(2));
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isBuffer(new Uint8Array(2));
|
|
|
* // => false
|
|
|
*/
|
|
|
var isBuffer = nativeIsBuffer || stubFalse;
|
|
|
|
|
|
module.exports = isBuffer;
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(41)(module)))
|
|
|
|
|
|
/***/ }),
|
|
|
/* 36 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
|
isObject = __webpack_require__(3);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var asyncTag = '[object AsyncFunction]',
|
|
|
funcTag = '[object Function]',
|
|
|
genTag = '[object GeneratorFunction]',
|
|
|
proxyTag = '[object Proxy]';
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is classified as a `Function` object.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isFunction(_);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isFunction(/abc/);
|
|
|
* // => false
|
|
|
*/
|
|
|
function isFunction(value) {
|
|
|
if (!isObject(value)) {
|
|
|
return false;
|
|
|
}
|
|
|
// The use of `Object#toString` avoids issues with the `typeof` operator
|
|
|
// in Safari 9 which returns 'object' for typed arrays and other constructors.
|
|
|
var tag = baseGetTag(value);
|
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
|
}
|
|
|
|
|
|
module.exports = isFunction;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 37 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is a valid array-like length.
|
|
|
*
|
|
|
* **Note:** This method is loosely based on
|
|
|
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isLength(3);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isLength(Number.MIN_VALUE);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isLength(Infinity);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isLength('3');
|
|
|
* // => false
|
|
|
*/
|
|
|
function isLength(value) {
|
|
|
return typeof value == 'number' &&
|
|
|
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
|
|
}
|
|
|
|
|
|
module.exports = isLength;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 38 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
|
isObjectLike = __webpack_require__(9);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var symbolTag = '[object Symbol]';
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is classified as a `Symbol` primitive or object.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isSymbol(Symbol.iterator);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isSymbol('abc');
|
|
|
* // => false
|
|
|
*/
|
|
|
function isSymbol(value) {
|
|
|
return typeof value == 'symbol' ||
|
|
|
(isObjectLike(value) && baseGetTag(value) == symbolTag);
|
|
|
}
|
|
|
|
|
|
module.exports = isSymbol;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 39 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayLikeKeys = __webpack_require__(47),
|
|
|
baseKeys = __webpack_require__(124),
|
|
|
isArrayLike = __webpack_require__(23);
|
|
|
|
|
|
/**
|
|
|
* Creates an array of the own enumerable property names of `object`.
|
|
|
*
|
|
|
* **Note:** Non-object values are coerced to objects. See the
|
|
|
* [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
|
|
|
* for more details.
|
|
|
*
|
|
|
* @static
|
|
|
* @since 0.1.0
|
|
|
* @memberOf _
|
|
|
* @category Object
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names.
|
|
|
* @example
|
|
|
*
|
|
|
* function Foo() {
|
|
|
* this.a = 1;
|
|
|
* this.b = 2;
|
|
|
* }
|
|
|
*
|
|
|
* Foo.prototype.c = 3;
|
|
|
*
|
|
|
* _.keys(new Foo);
|
|
|
* // => ['a', 'b'] (iteration order is not guaranteed)
|
|
|
*
|
|
|
* _.keys('hi');
|
|
|
* // => ['0', '1']
|
|
|
*/
|
|
|
function keys(object) {
|
|
|
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
|
|
|
}
|
|
|
|
|
|
module.exports = keys;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 40 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseMerge = __webpack_require__(126),
|
|
|
createAssigner = __webpack_require__(146);
|
|
|
|
|
|
/**
|
|
|
* This method is like `_.assign` except that it recursively merges own and
|
|
|
* inherited enumerable string keyed properties of source objects into the
|
|
|
* destination object. Source properties that resolve to `undefined` are
|
|
|
* skipped if a destination value exists. Array and plain object properties
|
|
|
* are merged recursively. Other objects and value types are overridden by
|
|
|
* assignment. Source objects are applied from left to right. Subsequent
|
|
|
* sources overwrite property assignments of previous sources.
|
|
|
*
|
|
|
* **Note:** This method mutates `object`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.5.0
|
|
|
* @category Object
|
|
|
* @param {Object} object The destination object.
|
|
|
* @param {...Object} [sources] The source objects.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = {
|
|
|
* 'a': [{ 'b': 2 }, { 'd': 4 }]
|
|
|
* };
|
|
|
*
|
|
|
* var other = {
|
|
|
* 'a': [{ 'c': 3 }, { 'e': 5 }]
|
|
|
* };
|
|
|
*
|
|
|
* _.merge(object, other);
|
|
|
* // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
|
|
|
*/
|
|
|
var merge = createAssigner(function(object, source, srcIndex) {
|
|
|
baseMerge(object, source, srcIndex);
|
|
|
});
|
|
|
|
|
|
module.exports = merge;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 41 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = function(module) {
|
|
|
if(!module.webpackPolyfill) {
|
|
|
module.deprecate = function() {};
|
|
|
module.paths = [];
|
|
|
// module.parent = undefined by default
|
|
|
if(!module.children) module.children = [];
|
|
|
Object.defineProperty(module, "loaded", {
|
|
|
enumerable: true,
|
|
|
get: function() {
|
|
|
return module.l;
|
|
|
}
|
|
|
});
|
|
|
Object.defineProperty(module, "id", {
|
|
|
enumerable: true,
|
|
|
get: function() {
|
|
|
return module.i;
|
|
|
}
|
|
|
});
|
|
|
module.webpackPolyfill = 1;
|
|
|
}
|
|
|
return module;
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 42 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
/**
|
|
|
* http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
|
|
|
*/
|
|
|
var Tracer = {
|
|
|
searchDirections: [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]],
|
|
|
create: function create(imageWrapper, labelWrapper) {
|
|
|
var imageData = imageWrapper.data,
|
|
|
labelData = labelWrapper.data,
|
|
|
searchDirections = this.searchDirections,
|
|
|
width = imageWrapper.size.x,
|
|
|
pos;
|
|
|
|
|
|
function _trace(current, color, label, edgelabel) {
|
|
|
var i, y, x;
|
|
|
|
|
|
for (i = 0; i < 7; i++) {
|
|
|
y = current.cy + searchDirections[current.dir][0];
|
|
|
x = current.cx + searchDirections[current.dir][1];
|
|
|
pos = y * width + x;
|
|
|
if (imageData[pos] === color && (labelData[pos] === 0 || labelData[pos] === label)) {
|
|
|
labelData[pos] = label;
|
|
|
current.cy = y;
|
|
|
current.cx = x;
|
|
|
return true;
|
|
|
} else {
|
|
|
if (labelData[pos] === 0) {
|
|
|
labelData[pos] = edgelabel;
|
|
|
}
|
|
|
current.dir = (current.dir + 1) % 8;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
function vertex2D(x, y, dir) {
|
|
|
return {
|
|
|
dir: dir,
|
|
|
x: x,
|
|
|
y: y,
|
|
|
next: null,
|
|
|
prev: null
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function _contourTracing(sy, sx, label, color, edgelabel) {
|
|
|
var Fv = null,
|
|
|
Cv,
|
|
|
P,
|
|
|
ldir,
|
|
|
current = {
|
|
|
cx: sx,
|
|
|
cy: sy,
|
|
|
dir: 0
|
|
|
};
|
|
|
|
|
|
if (_trace(current, color, label, edgelabel)) {
|
|
|
Fv = vertex2D(sx, sy, current.dir);
|
|
|
Cv = Fv;
|
|
|
ldir = current.dir;
|
|
|
P = vertex2D(current.cx, current.cy, 0);
|
|
|
P.prev = Cv;
|
|
|
Cv.next = P;
|
|
|
P.next = null;
|
|
|
Cv = P;
|
|
|
do {
|
|
|
current.dir = (current.dir + 6) % 8;
|
|
|
_trace(current, color, label, edgelabel);
|
|
|
if (ldir !== current.dir) {
|
|
|
Cv.dir = current.dir;
|
|
|
P = vertex2D(current.cx, current.cy, 0);
|
|
|
P.prev = Cv;
|
|
|
Cv.next = P;
|
|
|
P.next = null;
|
|
|
Cv = P;
|
|
|
} else {
|
|
|
Cv.dir = ldir;
|
|
|
Cv.x = current.cx;
|
|
|
Cv.y = current.cy;
|
|
|
}
|
|
|
ldir = current.dir;
|
|
|
} while (current.cx !== sx || current.cy !== sy);
|
|
|
Fv.prev = Cv.prev;
|
|
|
Cv.prev.next = Fv;
|
|
|
}
|
|
|
return Fv;
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
trace: function trace(current, color, label, edgelabel) {
|
|
|
return _trace(current, color, label, edgelabel);
|
|
|
},
|
|
|
contourTracing: function contourTracing(sy, sx, label, color, edgelabel) {
|
|
|
return _contourTracing(sy, sx, label, color, edgelabel);
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = Tracer;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 43 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _barcode_reader = __webpack_require__(10);
|
|
|
|
|
|
var _barcode_reader2 = _interopRequireDefault(_barcode_reader);
|
|
|
|
|
|
var _array_helper = __webpack_require__(13);
|
|
|
|
|
|
var _array_helper2 = _interopRequireDefault(_array_helper);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function Code39Reader() {
|
|
|
_barcode_reader2.default.call(this);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
ALPHABETH_STRING: { value: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%" },
|
|
|
ALPHABET: { value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37] },
|
|
|
CHARACTER_ENCODINGS: { value: [0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A] },
|
|
|
ASTERISK: { value: 0x094 },
|
|
|
FORMAT: { value: "code_39", writeable: false }
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype = Object.create(_barcode_reader2.default.prototype, properties);
|
|
|
Code39Reader.prototype.constructor = Code39Reader;
|
|
|
|
|
|
Code39Reader.prototype._toCounters = function (start, counter) {
|
|
|
var self = this,
|
|
|
numCounters = counter.length,
|
|
|
end = self._row.length,
|
|
|
isWhite = !self._row[start],
|
|
|
i,
|
|
|
counterPos = 0;
|
|
|
|
|
|
_array_helper2.default.init(counter, 0);
|
|
|
|
|
|
for (i = start; i < end; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
if (counterPos === numCounters) {
|
|
|
break;
|
|
|
} else {
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return counter;
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype._decode = function () {
|
|
|
var self = this,
|
|
|
counters = [0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
|
result = [],
|
|
|
start = self._findStart(),
|
|
|
decodedChar,
|
|
|
lastStart,
|
|
|
pattern,
|
|
|
nextStart;
|
|
|
|
|
|
if (!start) {
|
|
|
return null;
|
|
|
}
|
|
|
nextStart = self._nextSet(self._row, start.end);
|
|
|
|
|
|
do {
|
|
|
counters = self._toCounters(nextStart, counters);
|
|
|
pattern = self._toPattern(counters);
|
|
|
if (pattern < 0) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedChar = self._patternToChar(pattern);
|
|
|
if (decodedChar < 0) {
|
|
|
return null;
|
|
|
}
|
|
|
result.push(decodedChar);
|
|
|
lastStart = nextStart;
|
|
|
nextStart += _array_helper2.default.sum(counters);
|
|
|
nextStart = self._nextSet(self._row, nextStart);
|
|
|
} while (decodedChar !== '*');
|
|
|
result.pop();
|
|
|
|
|
|
if (!result.length) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (!self._verifyTrailingWhitespace(lastStart, nextStart, counters)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
code: result.join(""),
|
|
|
start: start.start,
|
|
|
end: nextStart,
|
|
|
startInfo: start,
|
|
|
decodedCodes: result
|
|
|
};
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype._verifyTrailingWhitespace = function (lastStart, nextStart, counters) {
|
|
|
var trailingWhitespaceEnd,
|
|
|
patternSize = _array_helper2.default.sum(counters);
|
|
|
|
|
|
trailingWhitespaceEnd = nextStart - lastStart - patternSize;
|
|
|
if (trailingWhitespaceEnd * 3 >= patternSize) {
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype._patternToChar = function (pattern) {
|
|
|
var i,
|
|
|
self = this;
|
|
|
|
|
|
for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {
|
|
|
if (self.CHARACTER_ENCODINGS[i] === pattern) {
|
|
|
return String.fromCharCode(self.ALPHABET[i]);
|
|
|
}
|
|
|
}
|
|
|
return -1;
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype._findNextWidth = function (counters, current) {
|
|
|
var i,
|
|
|
minWidth = Number.MAX_VALUE;
|
|
|
|
|
|
for (i = 0; i < counters.length; i++) {
|
|
|
if (counters[i] < minWidth && counters[i] > current) {
|
|
|
minWidth = counters[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return minWidth;
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype._toPattern = function (counters) {
|
|
|
var numCounters = counters.length,
|
|
|
maxNarrowWidth = 0,
|
|
|
numWideBars = numCounters,
|
|
|
wideBarWidth = 0,
|
|
|
self = this,
|
|
|
pattern,
|
|
|
i;
|
|
|
|
|
|
while (numWideBars > 3) {
|
|
|
maxNarrowWidth = self._findNextWidth(counters, maxNarrowWidth);
|
|
|
numWideBars = 0;
|
|
|
pattern = 0;
|
|
|
for (i = 0; i < numCounters; i++) {
|
|
|
if (counters[i] > maxNarrowWidth) {
|
|
|
pattern |= 1 << numCounters - 1 - i;
|
|
|
numWideBars++;
|
|
|
wideBarWidth += counters[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (numWideBars === 3) {
|
|
|
for (i = 0; i < numCounters && numWideBars > 0; i++) {
|
|
|
if (counters[i] > maxNarrowWidth) {
|
|
|
numWideBars--;
|
|
|
if (counters[i] * 2 >= wideBarWidth) {
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return pattern;
|
|
|
}
|
|
|
}
|
|
|
return -1;
|
|
|
};
|
|
|
|
|
|
Code39Reader.prototype._findStart = function () {
|
|
|
var self = this,
|
|
|
offset = self._nextSet(self._row),
|
|
|
patternStart = offset,
|
|
|
counter = [0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
|
counterPos = 0,
|
|
|
isWhite = false,
|
|
|
i,
|
|
|
j,
|
|
|
whiteSpaceMustStart;
|
|
|
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
// find start pattern
|
|
|
if (self._toPattern(counter) === self.ASTERISK) {
|
|
|
whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - (i - patternStart) / 4));
|
|
|
if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) {
|
|
|
return {
|
|
|
start: patternStart,
|
|
|
end: i
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
|
|
|
patternStart += counter[0] + counter[1];
|
|
|
for (j = 0; j < 7; j++) {
|
|
|
counter[j] = counter[j + 2];
|
|
|
}
|
|
|
counter[7] = 0;
|
|
|
counter[8] = 0;
|
|
|
counterPos--;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
exports.default = Code39Reader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 44 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = dot
|
|
|
|
|
|
/**
|
|
|
* Calculates the dot product of two vec2's
|
|
|
*
|
|
|
* @param {vec2} a the first operand
|
|
|
* @param {vec2} b the second operand
|
|
|
* @returns {Number} dot product of a and b
|
|
|
*/
|
|
|
function dot(a, b) {
|
|
|
return a[0] * b[0] + a[1] * b[1]
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 45 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var mapCacheClear = __webpack_require__(171),
|
|
|
mapCacheDelete = __webpack_require__(172),
|
|
|
mapCacheGet = __webpack_require__(173),
|
|
|
mapCacheHas = __webpack_require__(174),
|
|
|
mapCacheSet = __webpack_require__(175);
|
|
|
|
|
|
/**
|
|
|
* Creates a map cache object to store key-value pairs.
|
|
|
*
|
|
|
* @private
|
|
|
* @constructor
|
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
|
|
*/
|
|
|
function MapCache(entries) {
|
|
|
var index = -1,
|
|
|
length = entries == null ? 0 : entries.length;
|
|
|
|
|
|
this.clear();
|
|
|
while (++index < length) {
|
|
|
var entry = entries[index];
|
|
|
this.set(entry[0], entry[1]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Add methods to `MapCache`.
|
|
|
MapCache.prototype.clear = mapCacheClear;
|
|
|
MapCache.prototype['delete'] = mapCacheDelete;
|
|
|
MapCache.prototype.get = mapCacheGet;
|
|
|
MapCache.prototype.has = mapCacheHas;
|
|
|
MapCache.prototype.set = mapCacheSet;
|
|
|
|
|
|
module.exports = MapCache;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 46 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var ListCache = __webpack_require__(15),
|
|
|
stackClear = __webpack_require__(185),
|
|
|
stackDelete = __webpack_require__(186),
|
|
|
stackGet = __webpack_require__(187),
|
|
|
stackHas = __webpack_require__(188),
|
|
|
stackSet = __webpack_require__(189);
|
|
|
|
|
|
/**
|
|
|
* Creates a stack cache object to store key-value pairs.
|
|
|
*
|
|
|
* @private
|
|
|
* @constructor
|
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
|
|
*/
|
|
|
function Stack(entries) {
|
|
|
var data = this.__data__ = new ListCache(entries);
|
|
|
this.size = data.size;
|
|
|
}
|
|
|
|
|
|
// Add methods to `Stack`.
|
|
|
Stack.prototype.clear = stackClear;
|
|
|
Stack.prototype['delete'] = stackDelete;
|
|
|
Stack.prototype.get = stackGet;
|
|
|
Stack.prototype.has = stackHas;
|
|
|
Stack.prototype.set = stackSet;
|
|
|
|
|
|
module.exports = Stack;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 47 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseTimes = __webpack_require__(134),
|
|
|
isArguments = __webpack_require__(22),
|
|
|
isArray = __webpack_require__(2),
|
|
|
isBuffer = __webpack_require__(35),
|
|
|
isIndex = __webpack_require__(18),
|
|
|
isTypedArray = __webpack_require__(68);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* Creates an array of the enumerable property names of the array-like `value`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to query.
|
|
|
* @param {boolean} inherited Specify returning inherited property names.
|
|
|
* @returns {Array} Returns the array of property names.
|
|
|
*/
|
|
|
function arrayLikeKeys(value, inherited) {
|
|
|
var isArr = isArray(value),
|
|
|
isArg = !isArr && isArguments(value),
|
|
|
isBuff = !isArr && !isArg && isBuffer(value),
|
|
|
isType = !isArr && !isArg && !isBuff && isTypedArray(value),
|
|
|
skipIndexes = isArr || isArg || isBuff || isType,
|
|
|
result = skipIndexes ? baseTimes(value.length, String) : [],
|
|
|
length = result.length;
|
|
|
|
|
|
for (var key in value) {
|
|
|
if ((inherited || hasOwnProperty.call(value, key)) &&
|
|
|
!(skipIndexes && (
|
|
|
// Safari 9 has enumerable `arguments.length` in strict mode.
|
|
|
key == 'length' ||
|
|
|
// Node.js 0.10 has enumerable non-index properties on buffers.
|
|
|
(isBuff && (key == 'offset' || key == 'parent')) ||
|
|
|
// PhantomJS 2 has enumerable non-index properties on typed arrays.
|
|
|
(isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
|
|
|
// Skip index properties.
|
|
|
isIndex(key, length)
|
|
|
))) {
|
|
|
result.push(key);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = arrayLikeKeys;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 48 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `_.map` for arrays without support for iteratee
|
|
|
* shorthands.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} [array] The array to iterate over.
|
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
|
* @returns {Array} Returns the new mapped array.
|
|
|
*/
|
|
|
function arrayMap(array, iteratee) {
|
|
|
var index = -1,
|
|
|
length = array == null ? 0 : array.length,
|
|
|
result = Array(length);
|
|
|
|
|
|
while (++index < length) {
|
|
|
result[index] = iteratee(array[index], index, array);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = arrayMap;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 49 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `_.reduce` for arrays without support for
|
|
|
* iteratee shorthands.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} [array] The array to iterate over.
|
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
|
* @param {*} [accumulator] The initial value.
|
|
|
* @param {boolean} [initAccum] Specify using the first element of `array` as
|
|
|
* the initial value.
|
|
|
* @returns {*} Returns the accumulated value.
|
|
|
*/
|
|
|
function arrayReduce(array, iteratee, accumulator, initAccum) {
|
|
|
var index = -1,
|
|
|
length = array == null ? 0 : array.length;
|
|
|
|
|
|
if (initAccum && length) {
|
|
|
accumulator = array[++index];
|
|
|
}
|
|
|
while (++index < length) {
|
|
|
accumulator = iteratee(accumulator, array[index], index, array);
|
|
|
}
|
|
|
return accumulator;
|
|
|
}
|
|
|
|
|
|
module.exports = arrayReduce;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 50 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseAssignValue = __webpack_require__(30),
|
|
|
eq = __webpack_require__(21);
|
|
|
|
|
|
/**
|
|
|
* This function is like `assignValue` except that it doesn't assign
|
|
|
* `undefined` values.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to modify.
|
|
|
* @param {string} key The key of the property to assign.
|
|
|
* @param {*} value The value to assign.
|
|
|
*/
|
|
|
function assignMergeValue(object, key, value) {
|
|
|
if ((value !== undefined && !eq(object[key], value)) ||
|
|
|
(value === undefined && !(key in object))) {
|
|
|
baseAssignValue(object, key, value);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
module.exports = assignMergeValue;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 51 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var castPath = __webpack_require__(7),
|
|
|
toKey = __webpack_require__(20);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.get` without support for default values.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @param {Array|string} path The path of the property to get.
|
|
|
* @returns {*} Returns the resolved value.
|
|
|
*/
|
|
|
function baseGet(object, path) {
|
|
|
path = castPath(path, object);
|
|
|
|
|
|
var index = 0,
|
|
|
length = path.length;
|
|
|
|
|
|
while (object != null && index < length) {
|
|
|
object = object[toKey(path[index++])];
|
|
|
}
|
|
|
return (index && index == length) ? object : undefined;
|
|
|
}
|
|
|
|
|
|
module.exports = baseGet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 52 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayPush = __webpack_require__(28),
|
|
|
isArray = __webpack_require__(2);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `getAllKeys` and `getAllKeysIn` which uses
|
|
|
* `keysFunc` and `symbolsFunc` to get the enumerable property names and
|
|
|
* symbols of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @param {Function} keysFunc The function to get the keys of `object`.
|
|
|
* @param {Function} symbolsFunc The function to get the symbols of `object`.
|
|
|
* @returns {Array} Returns the array of property names and symbols.
|
|
|
*/
|
|
|
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
|
|
|
var result = keysFunc(object);
|
|
|
return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
|
|
|
}
|
|
|
|
|
|
module.exports = baseGetAllKeys;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 53 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(1);
|
|
|
|
|
|
/** Detect free variable `exports`. */
|
|
|
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
|
|
|
|
|
|
/** Detect free variable `module`. */
|
|
|
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
|
|
|
|
|
|
/** Detect the popular CommonJS extension `module.exports`. */
|
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var Buffer = moduleExports ? root.Buffer : undefined,
|
|
|
allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `buffer`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Buffer} buffer The buffer to clone.
|
|
|
* @param {boolean} [isDeep] Specify a deep clone.
|
|
|
* @returns {Buffer} Returns the cloned buffer.
|
|
|
*/
|
|
|
function cloneBuffer(buffer, isDeep) {
|
|
|
if (isDeep) {
|
|
|
return buffer.slice();
|
|
|
}
|
|
|
var length = buffer.length,
|
|
|
result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
|
|
|
|
|
|
buffer.copy(result);
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = cloneBuffer;
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(41)(module)))
|
|
|
|
|
|
/***/ }),
|
|
|
/* 54 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var cloneArrayBuffer = __webpack_require__(31);
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `typedArray`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} typedArray The typed array to clone.
|
|
|
* @param {boolean} [isDeep] Specify a deep clone.
|
|
|
* @returns {Object} Returns the cloned typed array.
|
|
|
*/
|
|
|
function cloneTypedArray(typedArray, isDeep) {
|
|
|
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
|
|
|
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
|
|
|
}
|
|
|
|
|
|
module.exports = cloneTypedArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 55 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Copies the values of `source` to `array`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} source The array to copy values from.
|
|
|
* @param {Array} [array=[]] The array to copy values to.
|
|
|
* @returns {Array} Returns `array`.
|
|
|
*/
|
|
|
function copyArray(source, array) {
|
|
|
var index = -1,
|
|
|
length = source.length;
|
|
|
|
|
|
array || (array = Array(length));
|
|
|
while (++index < length) {
|
|
|
array[index] = source[index];
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
module.exports = copyArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 56 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4);
|
|
|
|
|
|
var defineProperty = (function() {
|
|
|
try {
|
|
|
var func = getNative(Object, 'defineProperty');
|
|
|
func({}, '', {});
|
|
|
return func;
|
|
|
} catch (e) {}
|
|
|
}());
|
|
|
|
|
|
module.exports = defineProperty;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 57 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var flatten = __webpack_require__(192),
|
|
|
overRest = __webpack_require__(63),
|
|
|
setToString = __webpack_require__(64);
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `baseRest` which flattens the rest array.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to apply a rest parameter to.
|
|
|
* @returns {Function} Returns the new function.
|
|
|
*/
|
|
|
function flatRest(func) {
|
|
|
return setToString(overRest(func, undefined, flatten), func + '');
|
|
|
}
|
|
|
|
|
|
module.exports = flatRest;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 58 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
|
|
|
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
|
|
|
|
|
|
module.exports = freeGlobal;
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(70)))
|
|
|
|
|
|
/***/ }),
|
|
|
/* 59 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetAllKeys = __webpack_require__(52),
|
|
|
getSymbolsIn = __webpack_require__(60),
|
|
|
keysIn = __webpack_require__(24);
|
|
|
|
|
|
/**
|
|
|
* Creates an array of own and inherited enumerable property names and
|
|
|
* symbols of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names and symbols.
|
|
|
*/
|
|
|
function getAllKeysIn(object) {
|
|
|
return baseGetAllKeys(object, keysIn, getSymbolsIn);
|
|
|
}
|
|
|
|
|
|
module.exports = getAllKeysIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 60 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayPush = __webpack_require__(28),
|
|
|
getPrototype = __webpack_require__(32),
|
|
|
getSymbols = __webpack_require__(33),
|
|
|
stubArray = __webpack_require__(69);
|
|
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
|
var nativeGetSymbols = Object.getOwnPropertySymbols;
|
|
|
|
|
|
/**
|
|
|
* Creates an array of the own and inherited enumerable symbols of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of symbols.
|
|
|
*/
|
|
|
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
|
|
|
var result = [];
|
|
|
while (object) {
|
|
|
arrayPush(result, getSymbols(object));
|
|
|
object = getPrototype(object);
|
|
|
}
|
|
|
return result;
|
|
|
};
|
|
|
|
|
|
module.exports = getSymbolsIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 61 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseCreate = __webpack_require__(117),
|
|
|
getPrototype = __webpack_require__(32),
|
|
|
isPrototype = __webpack_require__(34);
|
|
|
|
|
|
/**
|
|
|
* Initializes an object clone.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to clone.
|
|
|
* @returns {Object} Returns the initialized clone.
|
|
|
*/
|
|
|
function initCloneObject(object) {
|
|
|
return (typeof object.constructor == 'function' && !isPrototype(object))
|
|
|
? baseCreate(getPrototype(object))
|
|
|
: {};
|
|
|
}
|
|
|
|
|
|
module.exports = initCloneObject;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 62 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Creates a unary function that invokes `func` with its argument transformed.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to wrap.
|
|
|
* @param {Function} transform The argument transform.
|
|
|
* @returns {Function} Returns the new function.
|
|
|
*/
|
|
|
function overArg(func, transform) {
|
|
|
return function(arg) {
|
|
|
return func(transform(arg));
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = overArg;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 63 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var apply = __webpack_require__(111);
|
|
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
|
var nativeMax = Math.max;
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `baseRest` which transforms the rest array.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to apply a rest parameter to.
|
|
|
* @param {number} [start=func.length-1] The start position of the rest parameter.
|
|
|
* @param {Function} transform The rest array transform.
|
|
|
* @returns {Function} Returns the new function.
|
|
|
*/
|
|
|
function overRest(func, start, transform) {
|
|
|
start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
|
|
|
return function() {
|
|
|
var args = arguments,
|
|
|
index = -1,
|
|
|
length = nativeMax(args.length - start, 0),
|
|
|
array = Array(length);
|
|
|
|
|
|
while (++index < length) {
|
|
|
array[index] = args[start + index];
|
|
|
}
|
|
|
index = -1;
|
|
|
var otherArgs = Array(start + 1);
|
|
|
while (++index < start) {
|
|
|
otherArgs[index] = args[index];
|
|
|
}
|
|
|
otherArgs[start] = transform(array);
|
|
|
return apply(func, this, otherArgs);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = overRest;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 64 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseSetToString = __webpack_require__(132),
|
|
|
shortOut = __webpack_require__(184);
|
|
|
|
|
|
/**
|
|
|
* Sets the `toString` method of `func` to return `string`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to modify.
|
|
|
* @param {Function} string The `toString` result.
|
|
|
* @returns {Function} Returns `func`.
|
|
|
*/
|
|
|
var setToString = shortOut(baseSetToString);
|
|
|
|
|
|
module.exports = setToString;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 65 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var funcProto = Function.prototype;
|
|
|
|
|
|
/** Used to resolve the decompiled source of functions. */
|
|
|
var funcToString = funcProto.toString;
|
|
|
|
|
|
/**
|
|
|
* Converts `func` to its source code.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to convert.
|
|
|
* @returns {string} Returns the source code.
|
|
|
*/
|
|
|
function toSource(func) {
|
|
|
if (func != null) {
|
|
|
try {
|
|
|
return funcToString.call(func);
|
|
|
} catch (e) {}
|
|
|
try {
|
|
|
return (func + '');
|
|
|
} catch (e) {}
|
|
|
}
|
|
|
return '';
|
|
|
}
|
|
|
|
|
|
module.exports = toSource;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 66 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* This method returns the first argument it receives.
|
|
|
*
|
|
|
* @static
|
|
|
* @since 0.1.0
|
|
|
* @memberOf _
|
|
|
* @category Util
|
|
|
* @param {*} value Any value.
|
|
|
* @returns {*} Returns `value`.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = { 'a': 1 };
|
|
|
*
|
|
|
* console.log(_.identity(object) === object);
|
|
|
* // => true
|
|
|
*/
|
|
|
function identity(value) {
|
|
|
return value;
|
|
|
}
|
|
|
|
|
|
module.exports = identity;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 67 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
|
getPrototype = __webpack_require__(32),
|
|
|
isObjectLike = __webpack_require__(9);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var objectTag = '[object Object]';
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var funcProto = Function.prototype,
|
|
|
objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to resolve the decompiled source of functions. */
|
|
|
var funcToString = funcProto.toString;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/** Used to infer the `Object` constructor. */
|
|
|
var objectCtorString = funcToString.call(Object);
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is a plain object, that is, an object created by the
|
|
|
* `Object` constructor or one with a `[[Prototype]]` of `null`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.8.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* function Foo() {
|
|
|
* this.a = 1;
|
|
|
* }
|
|
|
*
|
|
|
* _.isPlainObject(new Foo);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isPlainObject([1, 2, 3]);
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isPlainObject({ 'x': 0, 'y': 0 });
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isPlainObject(Object.create(null));
|
|
|
* // => true
|
|
|
*/
|
|
|
function isPlainObject(value) {
|
|
|
if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
|
|
|
return false;
|
|
|
}
|
|
|
var proto = getPrototype(value);
|
|
|
if (proto === null) {
|
|
|
return true;
|
|
|
}
|
|
|
var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
|
|
|
return typeof Ctor == 'function' && Ctor instanceof Ctor &&
|
|
|
funcToString.call(Ctor) == objectCtorString;
|
|
|
}
|
|
|
|
|
|
module.exports = isPlainObject;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 68 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseIsTypedArray = __webpack_require__(123),
|
|
|
baseUnary = __webpack_require__(136),
|
|
|
nodeUtil = __webpack_require__(180);
|
|
|
|
|
|
/* Node.js helper references. */
|
|
|
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is classified as a typed array.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 3.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isTypedArray(new Uint8Array);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isTypedArray([]);
|
|
|
* // => false
|
|
|
*/
|
|
|
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
|
|
|
|
|
|
module.exports = isTypedArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 69 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* This method returns a new empty array.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.13.0
|
|
|
* @category Util
|
|
|
* @returns {Array} Returns the new empty array.
|
|
|
* @example
|
|
|
*
|
|
|
* var arrays = _.times(2, _.stubArray);
|
|
|
*
|
|
|
* console.log(arrays);
|
|
|
* // => [[], []]
|
|
|
*
|
|
|
* console.log(arrays[0] === arrays[1]);
|
|
|
* // => false
|
|
|
*/
|
|
|
function stubArray() {
|
|
|
return [];
|
|
|
}
|
|
|
|
|
|
module.exports = stubArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 70 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
var g;
|
|
|
|
|
|
// This works in non-strict mode
|
|
|
g = (function() {
|
|
|
return this;
|
|
|
})();
|
|
|
|
|
|
try {
|
|
|
// This works if eval is allowed (see CSP)
|
|
|
g = g || Function("return this")() || (1,eval)("this");
|
|
|
} catch(e) {
|
|
|
// This works if the window reference is available
|
|
|
if(typeof window === "object")
|
|
|
g = window;
|
|
|
}
|
|
|
|
|
|
// g can still be undefined, but nothing to do about it...
|
|
|
// We return undefined, instead of nothing here, so it's
|
|
|
// easier to handle this case. if(!global) { ...}
|
|
|
|
|
|
module.exports = g;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 71 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _merge2 = __webpack_require__(40);
|
|
|
|
|
|
var _merge3 = _interopRequireDefault(_merge2);
|
|
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; // eslint-disable-line no-unused-vars
|
|
|
// eslint-disable-line no-unused-vars
|
|
|
|
|
|
|
|
|
var _typedefs = __webpack_require__(79);
|
|
|
|
|
|
var _typedefs2 = _interopRequireDefault(_typedefs);
|
|
|
|
|
|
var _webrtcAdapter = __webpack_require__(203);
|
|
|
|
|
|
var _webrtcAdapter2 = _interopRequireDefault(_webrtcAdapter);
|
|
|
|
|
|
var _image_wrapper = __webpack_require__(26);
|
|
|
|
|
|
var _image_wrapper2 = _interopRequireDefault(_image_wrapper);
|
|
|
|
|
|
var _barcode_locator = __webpack_require__(85);
|
|
|
|
|
|
var _barcode_locator2 = _interopRequireDefault(_barcode_locator);
|
|
|
|
|
|
var _barcode_decoder = __webpack_require__(82);
|
|
|
|
|
|
var _barcode_decoder2 = _interopRequireDefault(_barcode_decoder);
|
|
|
|
|
|
var _events = __webpack_require__(76);
|
|
|
|
|
|
var _events2 = _interopRequireDefault(_events);
|
|
|
|
|
|
var _camera_access = __webpack_require__(84);
|
|
|
|
|
|
var _camera_access2 = _interopRequireDefault(_camera_access);
|
|
|
|
|
|
var _image_debug = __webpack_require__(14);
|
|
|
|
|
|
var _image_debug2 = _interopRequireDefault(_image_debug);
|
|
|
|
|
|
var _result_collector = __webpack_require__(74);
|
|
|
|
|
|
var _result_collector2 = _interopRequireDefault(_result_collector);
|
|
|
|
|
|
var _config2 = __webpack_require__(80);
|
|
|
|
|
|
var _config3 = _interopRequireDefault(_config2);
|
|
|
|
|
|
var _input_stream = __webpack_require__(73);
|
|
|
|
|
|
var _input_stream2 = _interopRequireDefault(_input_stream);
|
|
|
|
|
|
var _frame_grabber = __webpack_require__(72);
|
|
|
|
|
|
var _frame_grabber2 = _interopRequireDefault(_frame_grabber);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var vec2 = {
|
|
|
clone: __webpack_require__(11)
|
|
|
};
|
|
|
|
|
|
var _inputStream,
|
|
|
_framegrabber,
|
|
|
_stopped,
|
|
|
_canvasContainer = {
|
|
|
ctx: {
|
|
|
image: null,
|
|
|
overlay: null
|
|
|
},
|
|
|
dom: {
|
|
|
image: null,
|
|
|
overlay: null
|
|
|
}
|
|
|
},
|
|
|
_inputImageWrapper,
|
|
|
_boxSize,
|
|
|
_decoder,
|
|
|
_workerPool = [],
|
|
|
_onUIThread = true,
|
|
|
_resultCollector,
|
|
|
_config = {};
|
|
|
|
|
|
function initializeData(imageWrapper) {
|
|
|
initBuffers(imageWrapper);
|
|
|
_decoder = _barcode_decoder2.default.create(_config.decoder, _inputImageWrapper);
|
|
|
}
|
|
|
|
|
|
function initInputStream(cb) {
|
|
|
var video;
|
|
|
if (_config.inputStream.type === "VideoStream") {
|
|
|
video = document.createElement("video");
|
|
|
_inputStream = _input_stream2.default.createVideoStream(video);
|
|
|
} else if (_config.inputStream.type === "ImageStream") {
|
|
|
_inputStream = _input_stream2.default.createImageStream();
|
|
|
} else if (_config.inputStream.type === "LiveStream") {
|
|
|
var $viewport = getViewPort();
|
|
|
if ($viewport) {
|
|
|
video = $viewport.querySelector("video");
|
|
|
if (!video) {
|
|
|
video = document.createElement("video");
|
|
|
$viewport.appendChild(video);
|
|
|
}
|
|
|
}
|
|
|
_inputStream = _input_stream2.default.createLiveStream(video);
|
|
|
_camera_access2.default.request(video, _config.inputStream.constraints).then(function () {
|
|
|
_inputStream.trigger("canrecord");
|
|
|
}).catch(function (err) {
|
|
|
return cb(err);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
_inputStream.setAttribute("preload", "auto");
|
|
|
_inputStream.setInputStream(_config.inputStream);
|
|
|
_inputStream.addEventListener("canrecord", canRecord.bind(undefined, cb));
|
|
|
}
|
|
|
|
|
|
function getViewPort() {
|
|
|
var target = _config.inputStream.target;
|
|
|
// Check if target is already a DOM element
|
|
|
if (target && target.nodeName && target.nodeType === 1) {
|
|
|
return target;
|
|
|
} else {
|
|
|
// Use '#interactive.viewport' as a fallback selector (backwards compatibility)
|
|
|
var selector = typeof target === 'string' ? target : '#interactive.viewport';
|
|
|
return document.querySelector(selector);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function canRecord(cb) {
|
|
|
_barcode_locator2.default.checkImageConstraints(_inputStream, _config.locator);
|
|
|
initCanvas(_config);
|
|
|
_framegrabber = _frame_grabber2.default.create(_inputStream, _canvasContainer.dom.image);
|
|
|
|
|
|
adjustWorkerPool(_config.numOfWorkers, function () {
|
|
|
if (_config.numOfWorkers === 0) {
|
|
|
initializeData();
|
|
|
}
|
|
|
ready(cb);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
function ready(cb) {
|
|
|
_inputStream.play();
|
|
|
cb();
|
|
|
}
|
|
|
|
|
|
function initCanvas() {
|
|
|
if (typeof document !== "undefined") {
|
|
|
var $viewport = getViewPort();
|
|
|
_canvasContainer.dom.image = document.querySelector("canvas.imgBuffer");
|
|
|
if (!_canvasContainer.dom.image) {
|
|
|
_canvasContainer.dom.image = document.createElement("canvas");
|
|
|
_canvasContainer.dom.image.className = "imgBuffer";
|
|
|
if ($viewport && _config.inputStream.type === "ImageStream") {
|
|
|
$viewport.appendChild(_canvasContainer.dom.image);
|
|
|
}
|
|
|
}
|
|
|
_canvasContainer.ctx.image = _canvasContainer.dom.image.getContext("2d");
|
|
|
_canvasContainer.dom.image.width = _inputStream.getCanvasSize().x;
|
|
|
_canvasContainer.dom.image.height = _inputStream.getCanvasSize().y;
|
|
|
|
|
|
_canvasContainer.dom.overlay = document.querySelector("canvas.drawingBuffer");
|
|
|
if (!_canvasContainer.dom.overlay) {
|
|
|
_canvasContainer.dom.overlay = document.createElement("canvas");
|
|
|
_canvasContainer.dom.overlay.className = "drawingBuffer";
|
|
|
if ($viewport) {
|
|
|
$viewport.appendChild(_canvasContainer.dom.overlay);
|
|
|
}
|
|
|
var clearFix = document.createElement("br");
|
|
|
clearFix.setAttribute("clear", "all");
|
|
|
if ($viewport) {
|
|
|
$viewport.appendChild(clearFix);
|
|
|
}
|
|
|
}
|
|
|
_canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext("2d");
|
|
|
_canvasContainer.dom.overlay.width = _inputStream.getCanvasSize().x;
|
|
|
_canvasContainer.dom.overlay.height = _inputStream.getCanvasSize().y;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function initBuffers(imageWrapper) {
|
|
|
if (imageWrapper) {
|
|
|
_inputImageWrapper = imageWrapper;
|
|
|
} else {
|
|
|
_inputImageWrapper = new _image_wrapper2.default({
|
|
|
x: _inputStream.getWidth(),
|
|
|
y: _inputStream.getHeight()
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (false) {
|
|
|
console.log(_inputImageWrapper.size);
|
|
|
}
|
|
|
_boxSize = [vec2.clone([0, 0]), vec2.clone([0, _inputImageWrapper.size.y]), vec2.clone([_inputImageWrapper.size.x, _inputImageWrapper.size.y]), vec2.clone([_inputImageWrapper.size.x, 0])];
|
|
|
_barcode_locator2.default.init(_inputImageWrapper, _config.locator);
|
|
|
}
|
|
|
|
|
|
function getBoundingBoxes() {
|
|
|
if (_config.locate) {
|
|
|
return _barcode_locator2.default.locate();
|
|
|
} else {
|
|
|
return [[vec2.clone(_boxSize[0]), vec2.clone(_boxSize[1]), vec2.clone(_boxSize[2]), vec2.clone(_boxSize[3])]];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function transformResult(result) {
|
|
|
var topRight = _inputStream.getTopRight(),
|
|
|
xOffset = topRight.x,
|
|
|
yOffset = topRight.y,
|
|
|
i;
|
|
|
|
|
|
if (xOffset === 0 && yOffset === 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (result.barcodes) {
|
|
|
for (i = 0; i < result.barcodes.length; i++) {
|
|
|
transformResult(result.barcodes[i]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (result.line && result.line.length === 2) {
|
|
|
moveLine(result.line);
|
|
|
}
|
|
|
|
|
|
if (result.box) {
|
|
|
moveBox(result.box);
|
|
|
}
|
|
|
|
|
|
if (result.boxes && result.boxes.length > 0) {
|
|
|
for (i = 0; i < result.boxes.length; i++) {
|
|
|
moveBox(result.boxes[i]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function moveBox(box) {
|
|
|
var corner = box.length;
|
|
|
|
|
|
while (corner--) {
|
|
|
box[corner][0] += xOffset;
|
|
|
box[corner][1] += yOffset;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function moveLine(line) {
|
|
|
line[0].x += xOffset;
|
|
|
line[0].y += yOffset;
|
|
|
line[1].x += xOffset;
|
|
|
line[1].y += yOffset;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function addResult(result, imageData) {
|
|
|
if (!imageData || !_resultCollector) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (result.barcodes) {
|
|
|
result.barcodes.filter(function (barcode) {
|
|
|
return barcode.codeResult;
|
|
|
}).forEach(function (barcode) {
|
|
|
return addResult(barcode, imageData);
|
|
|
});
|
|
|
} else if (result.codeResult) {
|
|
|
_resultCollector.addResult(imageData, _inputStream.getCanvasSize(), result.codeResult);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function hasCodeResult(result) {
|
|
|
return result && (result.barcodes ? result.barcodes.some(function (barcode) {
|
|
|
return barcode.codeResult;
|
|
|
}) : result.codeResult);
|
|
|
}
|
|
|
|
|
|
function publishResult(result, imageData) {
|
|
|
var resultToPublish = result;
|
|
|
|
|
|
if (result && _onUIThread) {
|
|
|
transformResult(result);
|
|
|
addResult(result, imageData);
|
|
|
resultToPublish = result.barcodes || result;
|
|
|
}
|
|
|
|
|
|
_events2.default.publish("processed", resultToPublish);
|
|
|
if (hasCodeResult(result)) {
|
|
|
_events2.default.publish("detected", resultToPublish);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function locateAndDecode() {
|
|
|
var result, boxes;
|
|
|
|
|
|
boxes = getBoundingBoxes();
|
|
|
if (boxes) {
|
|
|
result = _decoder.decodeFromBoundingBoxes(boxes);
|
|
|
result = result || {};
|
|
|
result.boxes = boxes;
|
|
|
publishResult(result, _inputImageWrapper.data);
|
|
|
} else {
|
|
|
publishResult();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function update() {
|
|
|
var availableWorker;
|
|
|
|
|
|
if (_onUIThread) {
|
|
|
if (_workerPool.length > 0) {
|
|
|
availableWorker = _workerPool.filter(function (workerThread) {
|
|
|
return !workerThread.busy;
|
|
|
})[0];
|
|
|
if (availableWorker) {
|
|
|
_framegrabber.attachData(availableWorker.imageData);
|
|
|
} else {
|
|
|
return; // all workers are busy
|
|
|
}
|
|
|
} else {
|
|
|
_framegrabber.attachData(_inputImageWrapper.data);
|
|
|
}
|
|
|
if (_framegrabber.grab()) {
|
|
|
if (availableWorker) {
|
|
|
availableWorker.busy = true;
|
|
|
availableWorker.worker.postMessage({
|
|
|
cmd: 'process',
|
|
|
imageData: availableWorker.imageData
|
|
|
}, [availableWorker.imageData.buffer]);
|
|
|
} else {
|
|
|
locateAndDecode();
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
locateAndDecode();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function startContinuousUpdate() {
|
|
|
var next = null,
|
|
|
delay = 1000 / (_config.frequency || 60);
|
|
|
|
|
|
_stopped = false;
|
|
|
(function frame(timestamp) {
|
|
|
next = next || timestamp;
|
|
|
if (!_stopped) {
|
|
|
if (timestamp >= next) {
|
|
|
next += delay;
|
|
|
update();
|
|
|
}
|
|
|
window.requestAnimFrame(frame);
|
|
|
}
|
|
|
})(performance.now());
|
|
|
}
|
|
|
|
|
|
function _start() {
|
|
|
if (_onUIThread && _config.inputStream.type === "LiveStream") {
|
|
|
startContinuousUpdate();
|
|
|
} else {
|
|
|
update();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function initWorker(cb) {
|
|
|
var blobURL,
|
|
|
workerThread = {
|
|
|
worker: undefined,
|
|
|
imageData: new Uint8Array(_inputStream.getWidth() * _inputStream.getHeight()),
|
|
|
busy: true
|
|
|
};
|
|
|
|
|
|
blobURL = generateWorkerBlob();
|
|
|
workerThread.worker = new Worker(blobURL);
|
|
|
|
|
|
workerThread.worker.onmessage = function (e) {
|
|
|
if (e.data.event === 'initialized') {
|
|
|
URL.revokeObjectURL(blobURL);
|
|
|
workerThread.busy = false;
|
|
|
workerThread.imageData = new Uint8Array(e.data.imageData);
|
|
|
if (false) {
|
|
|
console.log("Worker initialized");
|
|
|
}
|
|
|
return cb(workerThread);
|
|
|
} else if (e.data.event === 'processed') {
|
|
|
workerThread.imageData = new Uint8Array(e.data.imageData);
|
|
|
workerThread.busy = false;
|
|
|
publishResult(e.data.result, workerThread.imageData);
|
|
|
} else if (e.data.event === 'error') {
|
|
|
if (false) {
|
|
|
console.log("Worker error: " + e.data.message);
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
workerThread.worker.postMessage({
|
|
|
cmd: 'init',
|
|
|
size: { x: _inputStream.getWidth(), y: _inputStream.getHeight() },
|
|
|
imageData: workerThread.imageData,
|
|
|
config: configForWorker(_config)
|
|
|
}, [workerThread.imageData.buffer]);
|
|
|
}
|
|
|
|
|
|
function configForWorker(config) {
|
|
|
return _extends({}, config, {
|
|
|
inputStream: _extends({}, config.inputStream, {
|
|
|
target: null
|
|
|
})
|
|
|
});
|
|
|
}
|
|
|
|
|
|
function workerInterface(factory) {
|
|
|
/* eslint-disable no-undef*/
|
|
|
if (factory) {
|
|
|
var Quagga = factory().default;
|
|
|
if (!Quagga) {
|
|
|
self.postMessage({ 'event': 'error', message: 'Quagga could not be created' });
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
var imageWrapper;
|
|
|
|
|
|
self.onmessage = function (e) {
|
|
|
if (e.data.cmd === 'init') {
|
|
|
var config = e.data.config;
|
|
|
config.numOfWorkers = 0;
|
|
|
imageWrapper = new Quagga.ImageWrapper({
|
|
|
x: e.data.size.x,
|
|
|
y: e.data.size.y
|
|
|
}, new Uint8Array(e.data.imageData));
|
|
|
Quagga.init(config, ready, imageWrapper);
|
|
|
Quagga.onProcessed(onProcessed);
|
|
|
} else if (e.data.cmd === 'process') {
|
|
|
imageWrapper.data = new Uint8Array(e.data.imageData);
|
|
|
Quagga.start();
|
|
|
} else if (e.data.cmd === 'setReaders') {
|
|
|
Quagga.setReaders(e.data.readers);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function onProcessed(result) {
|
|
|
self.postMessage({
|
|
|
'event': 'processed',
|
|
|
imageData: imageWrapper.data,
|
|
|
result: result
|
|
|
}, [imageWrapper.data.buffer]);
|
|
|
}
|
|
|
|
|
|
function ready() {
|
|
|
// eslint-disable-line
|
|
|
self.postMessage({ 'event': 'initialized', imageData: imageWrapper.data }, [imageWrapper.data.buffer]);
|
|
|
}
|
|
|
|
|
|
/* eslint-enable */
|
|
|
}
|
|
|
|
|
|
function generateWorkerBlob() {
|
|
|
var blob, factorySource;
|
|
|
|
|
|
/* jshint ignore:start */
|
|
|
if (typeof __factorySource__ !== 'undefined') {
|
|
|
factorySource = __factorySource__; // eslint-disable-line no-undef
|
|
|
}
|
|
|
/* jshint ignore:end */
|
|
|
|
|
|
blob = new Blob(['(' + workerInterface.toString() + ')(' + factorySource + ');'], { type: 'text/javascript' });
|
|
|
|
|
|
return window.URL.createObjectURL(blob);
|
|
|
}
|
|
|
|
|
|
function _setReaders(readers) {
|
|
|
if (_decoder) {
|
|
|
_decoder.setReaders(readers);
|
|
|
} else if (_onUIThread && _workerPool.length > 0) {
|
|
|
_workerPool.forEach(function (workerThread) {
|
|
|
workerThread.worker.postMessage({ cmd: 'setReaders', readers: readers });
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function adjustWorkerPool(capacity, cb) {
|
|
|
var increaseBy = capacity - _workerPool.length;
|
|
|
if (increaseBy === 0) {
|
|
|
return cb && cb();
|
|
|
}
|
|
|
if (increaseBy < 0) {
|
|
|
var workersToTerminate = _workerPool.slice(increaseBy);
|
|
|
workersToTerminate.forEach(function (workerThread) {
|
|
|
workerThread.worker.terminate();
|
|
|
if (false) {
|
|
|
console.log("Worker terminated!");
|
|
|
}
|
|
|
});
|
|
|
_workerPool = _workerPool.slice(0, increaseBy);
|
|
|
return cb && cb();
|
|
|
} else {
|
|
|
var workerInitialized = function workerInitialized(workerThread) {
|
|
|
_workerPool.push(workerThread);
|
|
|
if (_workerPool.length >= capacity) {
|
|
|
cb && cb();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
for (var i = 0; i < increaseBy; i++) {
|
|
|
initWorker(workerInitialized);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
exports.default = {
|
|
|
init: function init(config, cb, imageWrapper) {
|
|
|
_config = (0, _merge3.default)({}, _config3.default, config);
|
|
|
if (imageWrapper) {
|
|
|
_onUIThread = false;
|
|
|
initializeData(imageWrapper);
|
|
|
return cb();
|
|
|
} else {
|
|
|
initInputStream(cb);
|
|
|
}
|
|
|
},
|
|
|
start: function start() {
|
|
|
_start();
|
|
|
},
|
|
|
stop: function stop() {
|
|
|
_stopped = true;
|
|
|
adjustWorkerPool(0);
|
|
|
if (_config.inputStream.type === "LiveStream") {
|
|
|
_camera_access2.default.release();
|
|
|
_inputStream.clearEventHandlers();
|
|
|
}
|
|
|
},
|
|
|
pause: function pause() {
|
|
|
_stopped = true;
|
|
|
},
|
|
|
onDetected: function onDetected(callback) {
|
|
|
_events2.default.subscribe("detected", callback);
|
|
|
},
|
|
|
offDetected: function offDetected(callback) {
|
|
|
_events2.default.unsubscribe("detected", callback);
|
|
|
},
|
|
|
onProcessed: function onProcessed(callback) {
|
|
|
_events2.default.subscribe("processed", callback);
|
|
|
},
|
|
|
offProcessed: function offProcessed(callback) {
|
|
|
_events2.default.unsubscribe("processed", callback);
|
|
|
},
|
|
|
setReaders: function setReaders(readers) {
|
|
|
_setReaders(readers);
|
|
|
},
|
|
|
registerResultCollector: function registerResultCollector(resultCollector) {
|
|
|
if (resultCollector && typeof resultCollector.addResult === 'function') {
|
|
|
_resultCollector = resultCollector;
|
|
|
}
|
|
|
},
|
|
|
canvas: _canvasContainer,
|
|
|
decodeSingle: function decodeSingle(config, resultCallback) {
|
|
|
var _this = this;
|
|
|
config = (0, _merge3.default)({
|
|
|
inputStream: {
|
|
|
type: "ImageStream",
|
|
|
sequence: false,
|
|
|
size: 800,
|
|
|
src: config.src,
|
|
|
mime : config.mime
|
|
|
},
|
|
|
numOfWorkers: false ? 0 : 1,
|
|
|
locator: {
|
|
|
halfSample: false
|
|
|
}
|
|
|
}, config);
|
|
|
this.init(config, function () {
|
|
|
_events2.default.once("processed", function (result) {
|
|
|
_this.stop();
|
|
|
resultCallback.call(null, result);
|
|
|
}, true);
|
|
|
_start();
|
|
|
});
|
|
|
},
|
|
|
ImageWrapper: _image_wrapper2.default,
|
|
|
ImageDebug: _image_debug2.default,
|
|
|
ResultCollector: _result_collector2.default,
|
|
|
CameraAccess: _camera_access2.default
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 72 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
var CVUtils = __webpack_require__(25),
|
|
|
Ndarray = __webpack_require__(212),
|
|
|
Interp2D = __webpack_require__(213).d2;
|
|
|
|
|
|
var FrameGrabber = {};
|
|
|
|
|
|
FrameGrabber.create = function (inputStream) {
|
|
|
var _that = {},
|
|
|
_streamConfig = inputStream.getConfig(),
|
|
|
_video_size = CVUtils.imageRef(inputStream.getRealWidth(), inputStream.getRealHeight()),
|
|
|
_canvasSize = inputStream.getCanvasSize(),
|
|
|
_size = CVUtils.imageRef(inputStream.getWidth(), inputStream.getHeight()),
|
|
|
_topRight = inputStream.getTopRight(),
|
|
|
_data = new Uint8Array(_size.x * _size.y),
|
|
|
_grayData = new Uint8Array(_video_size.x * _video_size.y),
|
|
|
_canvasData = new Uint8Array(_canvasSize.x * _canvasSize.y),
|
|
|
_grayImageArray = Ndarray(_grayData, [_video_size.y, _video_size.x]).transpose(1, 0),
|
|
|
_canvasImageArray = Ndarray(_canvasData, [_canvasSize.y, _canvasSize.x]).transpose(1, 0),
|
|
|
_targetImageArray = _canvasImageArray.hi(_topRight.x + _size.x, _topRight.y + _size.y).lo(_topRight.x, _topRight.y),
|
|
|
_stepSizeX = _video_size.x / _canvasSize.x,
|
|
|
_stepSizeY = _video_size.y / _canvasSize.y;
|
|
|
|
|
|
console.log("FrameGrabber", JSON.stringify({
|
|
|
videoSize: _grayImageArray.shape,
|
|
|
canvasSize: _canvasImageArray.shape,
|
|
|
stepSize: [_stepSizeX, _stepSizeY],
|
|
|
size: _targetImageArray.shape,
|
|
|
topRight: _topRight
|
|
|
}));
|
|
|
|
|
|
/**
|
|
|
* Uses the given array as frame-buffer
|
|
|
*/
|
|
|
_that.attachData = function (data) {
|
|
|
_data = data;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the used frame-buffer
|
|
|
*/
|
|
|
_that.getData = function () {
|
|
|
return _data;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Fetches a frame from the input-stream and puts into the frame-buffer.
|
|
|
* The image-data is converted to gray-scale and then half-sampled if configured.
|
|
|
*/
|
|
|
_that.grab = function () {
|
|
|
var frame = inputStream.getFrame();
|
|
|
|
|
|
if (frame) {
|
|
|
this.scaleAndCrop(frame);
|
|
|
return true;
|
|
|
} else {
|
|
|
return false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
_that.scaleAndCrop = function (frame) {
|
|
|
var x, y;
|
|
|
|
|
|
// 1. compute full-sized gray image
|
|
|
CVUtils.computeGray(frame.data, _grayData);
|
|
|
|
|
|
// 2. interpolate
|
|
|
for (y = 0; y < _canvasSize.y; y++) {
|
|
|
for (x = 0; x < _canvasSize.x; x++) {
|
|
|
_canvasImageArray.set(x, y, Interp2D(_grayImageArray, x * _stepSizeX, y * _stepSizeY) | 0);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// targetImageArray must be equal to targetSize
|
|
|
if (_targetImageArray.shape[0] !== _size.x || _targetImageArray.shape[1] !== _size.y) {
|
|
|
throw new Error("Shapes do not match!");
|
|
|
}
|
|
|
|
|
|
// 3. crop
|
|
|
for (y = 0; y < _size.y; y++) {
|
|
|
for (x = 0; x < _size.x; x++) {
|
|
|
_data[y * _size.x + x] = _targetImageArray.get(x, y);
|
|
|
}
|
|
|
}
|
|
|
}, _that.getSize = function () {
|
|
|
return _size;
|
|
|
};
|
|
|
|
|
|
return _that;
|
|
|
};
|
|
|
|
|
|
module.exports = FrameGrabber;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 73 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
var GetPixels = __webpack_require__(211);
|
|
|
|
|
|
var InputStream = {};
|
|
|
|
|
|
InputStream.createImageStream = function () {
|
|
|
var that = {};
|
|
|
var _config = null;
|
|
|
|
|
|
var width = 0,
|
|
|
height = 0,
|
|
|
frameIdx = 0,
|
|
|
paused = true,
|
|
|
loaded = false,
|
|
|
frame = null,
|
|
|
baseUrl,
|
|
|
mime,
|
|
|
ended = false,
|
|
|
size,
|
|
|
calculatedWidth,
|
|
|
calculatedHeight,
|
|
|
_eventNames = ['canrecord', 'ended'],
|
|
|
_eventHandlers = {},
|
|
|
_topRight = { x: 0, y: 0 },
|
|
|
_canvasSize = { x: 0, y: 0 };
|
|
|
|
|
|
function loadImages() {
|
|
|
loaded = false;
|
|
|
|
|
|
GetPixels(baseUrl, mime, function (err, pixels) {
|
|
|
if (err) {
|
|
|
console.log(err);
|
|
|
exit(1);
|
|
|
}
|
|
|
loaded = true;
|
|
|
console.log(pixels.shape);
|
|
|
frame = pixels;
|
|
|
width = pixels.shape[0];
|
|
|
height = pixels.shape[1];
|
|
|
calculatedWidth = _config.size ? width / height > 1 ? _config.size : Math.floor(width / height * _config.size) : width;
|
|
|
calculatedHeight = _config.size ? width / height > 1 ? Math.floor(height / width * _config.size) : _config.size : height;
|
|
|
|
|
|
_canvasSize.x = calculatedWidth;
|
|
|
_canvasSize.y = calculatedHeight;
|
|
|
|
|
|
setTimeout(function () {
|
|
|
publishEvent("canrecord", []);
|
|
|
}, 0);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
function publishEvent(eventName, args) {
|
|
|
var j,
|
|
|
handlers = _eventHandlers[eventName];
|
|
|
|
|
|
if (handlers && handlers.length > 0) {
|
|
|
for (j = 0; j < handlers.length; j++) {
|
|
|
handlers[j].apply(that, args);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
that.trigger = publishEvent;
|
|
|
|
|
|
that.getWidth = function () {
|
|
|
return calculatedWidth;
|
|
|
};
|
|
|
|
|
|
that.getHeight = function () {
|
|
|
return calculatedHeight;
|
|
|
};
|
|
|
|
|
|
that.setWidth = function (width) {
|
|
|
calculatedWidth = width;
|
|
|
};
|
|
|
|
|
|
that.setHeight = function (height) {
|
|
|
calculatedHeight = height;
|
|
|
};
|
|
|
|
|
|
that.getRealWidth = function () {
|
|
|
return width;
|
|
|
};
|
|
|
|
|
|
that.getRealHeight = function () {
|
|
|
return height;
|
|
|
};
|
|
|
|
|
|
that.setInputStream = function (stream) {
|
|
|
_config = stream;
|
|
|
baseUrl = _config.src;
|
|
|
mime = _config.mime;
|
|
|
size = 1;
|
|
|
loadImages();
|
|
|
};
|
|
|
|
|
|
that.ended = function () {
|
|
|
return ended;
|
|
|
};
|
|
|
|
|
|
that.setAttribute = function () {};
|
|
|
|
|
|
that.getConfig = function () {
|
|
|
return _config;
|
|
|
};
|
|
|
|
|
|
that.pause = function () {
|
|
|
paused = true;
|
|
|
};
|
|
|
|
|
|
that.play = function () {
|
|
|
paused = false;
|
|
|
};
|
|
|
|
|
|
that.setCurrentTime = function (time) {
|
|
|
frameIdx = time;
|
|
|
};
|
|
|
|
|
|
that.addEventListener = function (event, f) {
|
|
|
if (_eventNames.indexOf(event) !== -1) {
|
|
|
if (!_eventHandlers[event]) {
|
|
|
_eventHandlers[event] = [];
|
|
|
}
|
|
|
_eventHandlers[event].push(f);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
that.setTopRight = function (topRight) {
|
|
|
_topRight.x = topRight.x;
|
|
|
_topRight.y = topRight.y;
|
|
|
};
|
|
|
|
|
|
that.getTopRight = function () {
|
|
|
return _topRight;
|
|
|
};
|
|
|
|
|
|
that.setCanvasSize = function (size) {
|
|
|
_canvasSize.x = size.x;
|
|
|
_canvasSize.y = size.y;
|
|
|
};
|
|
|
|
|
|
that.getCanvasSize = function () {
|
|
|
return _canvasSize;
|
|
|
};
|
|
|
|
|
|
that.getFrame = function () {
|
|
|
if (!loaded) {
|
|
|
return null;
|
|
|
}
|
|
|
return frame;
|
|
|
};
|
|
|
|
|
|
return that;
|
|
|
};
|
|
|
|
|
|
module.exports = InputStream;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 74 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _image_debug = __webpack_require__(14);
|
|
|
|
|
|
var _image_debug2 = _interopRequireDefault(_image_debug);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function contains(codeResult, list) {
|
|
|
if (list) {
|
|
|
return list.some(function (item) {
|
|
|
return Object.keys(item).every(function (key) {
|
|
|
return item[key] === codeResult[key];
|
|
|
});
|
|
|
});
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
function passesFilter(codeResult, filter) {
|
|
|
if (typeof filter === 'function') {
|
|
|
return filter(codeResult);
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
exports.default = {
|
|
|
create: function create(config) {
|
|
|
var canvas = document.createElement("canvas"),
|
|
|
ctx = canvas.getContext("2d"),
|
|
|
results = [],
|
|
|
capacity = config.capacity || 20,
|
|
|
capture = config.capture === true;
|
|
|
|
|
|
function matchesConstraints(codeResult) {
|
|
|
return capacity && codeResult && !contains(codeResult, config.blacklist) && passesFilter(codeResult, config.filter);
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
addResult: function addResult(data, imageSize, codeResult) {
|
|
|
var result = {};
|
|
|
|
|
|
if (matchesConstraints(codeResult)) {
|
|
|
capacity--;
|
|
|
result.codeResult = codeResult;
|
|
|
if (capture) {
|
|
|
canvas.width = imageSize.x;
|
|
|
canvas.height = imageSize.y;
|
|
|
_image_debug2.default.drawImage(data, imageSize, ctx);
|
|
|
result.frame = canvas.toDataURL();
|
|
|
}
|
|
|
results.push(result);
|
|
|
}
|
|
|
},
|
|
|
getResults: function getResults() {
|
|
|
return results;
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 75 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
var vec2 = {
|
|
|
clone: __webpack_require__(11),
|
|
|
dot: __webpack_require__(44)
|
|
|
};
|
|
|
/**
|
|
|
* Creates a cluster for grouping similar orientations of datapoints
|
|
|
*/
|
|
|
exports.default = {
|
|
|
create: function create(point, threshold) {
|
|
|
var points = [],
|
|
|
center = {
|
|
|
rad: 0,
|
|
|
vec: vec2.clone([0, 0])
|
|
|
},
|
|
|
pointMap = {};
|
|
|
|
|
|
function init() {
|
|
|
_add(point);
|
|
|
updateCenter();
|
|
|
}
|
|
|
|
|
|
function _add(pointToAdd) {
|
|
|
pointMap[pointToAdd.id] = pointToAdd;
|
|
|
points.push(pointToAdd);
|
|
|
}
|
|
|
|
|
|
function updateCenter() {
|
|
|
var i,
|
|
|
sum = 0;
|
|
|
for (i = 0; i < points.length; i++) {
|
|
|
sum += points[i].rad;
|
|
|
}
|
|
|
center.rad = sum / points.length;
|
|
|
center.vec = vec2.clone([Math.cos(center.rad), Math.sin(center.rad)]);
|
|
|
}
|
|
|
|
|
|
init();
|
|
|
|
|
|
return {
|
|
|
add: function add(pointToAdd) {
|
|
|
if (!pointMap[pointToAdd.id]) {
|
|
|
_add(pointToAdd);
|
|
|
updateCenter();
|
|
|
}
|
|
|
},
|
|
|
fits: function fits(otherPoint) {
|
|
|
// check cosine similarity to center-angle
|
|
|
var similarity = Math.abs(vec2.dot(otherPoint.point.vec, center.vec));
|
|
|
if (similarity > threshold) {
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
},
|
|
|
getPoints: function getPoints() {
|
|
|
return points;
|
|
|
},
|
|
|
getCenter: function getCenter() {
|
|
|
return center;
|
|
|
}
|
|
|
};
|
|
|
},
|
|
|
createPoint: function createPoint(newPoint, id, property) {
|
|
|
return {
|
|
|
rad: newPoint[property],
|
|
|
point: newPoint,
|
|
|
id: id
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 76 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
exports.default = function () {
|
|
|
var events = {};
|
|
|
|
|
|
function getEvent(eventName) {
|
|
|
if (!events[eventName]) {
|
|
|
events[eventName] = {
|
|
|
subscribers: []
|
|
|
};
|
|
|
}
|
|
|
return events[eventName];
|
|
|
}
|
|
|
|
|
|
function clearEvents() {
|
|
|
events = {};
|
|
|
}
|
|
|
|
|
|
function publishSubscription(subscription, data) {
|
|
|
if (subscription.async) {
|
|
|
setTimeout(function () {
|
|
|
subscription.callback(data);
|
|
|
}, 4);
|
|
|
} else {
|
|
|
subscription.callback(data);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function _subscribe(event, callback, async) {
|
|
|
var subscription;
|
|
|
|
|
|
if (typeof callback === "function") {
|
|
|
subscription = {
|
|
|
callback: callback,
|
|
|
async: async
|
|
|
};
|
|
|
} else {
|
|
|
subscription = callback;
|
|
|
if (!subscription.callback) {
|
|
|
throw "Callback was not specified on options";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
getEvent(event).subscribers.push(subscription);
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
subscribe: function subscribe(event, callback, async) {
|
|
|
return _subscribe(event, callback, async);
|
|
|
},
|
|
|
publish: function publish(eventName, data) {
|
|
|
var event = getEvent(eventName),
|
|
|
subscribers = event.subscribers;
|
|
|
|
|
|
// Publish one-time subscriptions
|
|
|
subscribers.filter(function (subscriber) {
|
|
|
return !!subscriber.once;
|
|
|
}).forEach(function (subscriber) {
|
|
|
publishSubscription(subscriber, data);
|
|
|
});
|
|
|
|
|
|
// remove them from the subscriber
|
|
|
event.subscribers = subscribers.filter(function (subscriber) {
|
|
|
return !subscriber.once;
|
|
|
});
|
|
|
|
|
|
// publish the rest
|
|
|
event.subscribers.forEach(function (subscriber) {
|
|
|
publishSubscription(subscriber, data);
|
|
|
});
|
|
|
},
|
|
|
once: function once(event, callback, async) {
|
|
|
_subscribe(event, {
|
|
|
callback: callback,
|
|
|
async: async,
|
|
|
once: true
|
|
|
});
|
|
|
},
|
|
|
unsubscribe: function unsubscribe(eventName, callback) {
|
|
|
var event;
|
|
|
|
|
|
if (eventName) {
|
|
|
event = getEvent(eventName);
|
|
|
if (event && callback) {
|
|
|
event.subscribers = event.subscribers.filter(function (subscriber) {
|
|
|
return subscriber.callback !== callback;
|
|
|
});
|
|
|
} else {
|
|
|
event.subscribers = [];
|
|
|
}
|
|
|
} else {
|
|
|
clearEvents();
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
}();
|
|
|
|
|
|
/***/ }),
|
|
|
/* 77 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
exports.enumerateDevices = enumerateDevices;
|
|
|
exports.getUserMedia = getUserMedia;
|
|
|
function enumerateDevices() {
|
|
|
if (navigator.mediaDevices && typeof navigator.mediaDevices.enumerateDevices === 'function') {
|
|
|
return navigator.mediaDevices.enumerateDevices();
|
|
|
}
|
|
|
return Promise.reject(new Error('enumerateDevices is not defined'));
|
|
|
};
|
|
|
|
|
|
function getUserMedia(constraints) {
|
|
|
if (navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function') {
|
|
|
return navigator.mediaDevices.getUserMedia(constraints);
|
|
|
}
|
|
|
return Promise.reject(new Error('getUserMedia is not defined'));
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 78 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
/**
|
|
|
* Construct representing a part of another {ImageWrapper}. Shares data
|
|
|
* between the parent and the child.
|
|
|
* @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)
|
|
|
* @param size {ImageRef} The size of the resulting image
|
|
|
* @param I {ImageWrapper} The {ImageWrapper} to share from
|
|
|
* @returns {SubImage} A shared part of the original image
|
|
|
*/
|
|
|
function SubImage(from, size, I) {
|
|
|
if (!I) {
|
|
|
I = {
|
|
|
data: null,
|
|
|
size: size
|
|
|
};
|
|
|
}
|
|
|
this.data = I.data;
|
|
|
this.originalSize = I.size;
|
|
|
this.I = I;
|
|
|
|
|
|
this.from = from;
|
|
|
this.size = size;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Displays the {SubImage} in a given canvas
|
|
|
* @param canvas {Canvas} The canvas element to write to
|
|
|
* @param scale {Number} Scale which is applied to each pixel-value
|
|
|
*/
|
|
|
SubImage.prototype.show = function (canvas, scale) {
|
|
|
var ctx, frame, data, current, y, x, pixel;
|
|
|
|
|
|
if (!scale) {
|
|
|
scale = 1.0;
|
|
|
}
|
|
|
ctx = canvas.getContext('2d');
|
|
|
canvas.width = this.size.x;
|
|
|
canvas.height = this.size.y;
|
|
|
frame = ctx.getImageData(0, 0, canvas.width, canvas.height);
|
|
|
data = frame.data;
|
|
|
current = 0;
|
|
|
for (y = 0; y < this.size.y; y++) {
|
|
|
for (x = 0; x < this.size.x; x++) {
|
|
|
pixel = y * this.size.x + x;
|
|
|
current = this.get(x, y) * scale;
|
|
|
data[pixel * 4 + 0] = current;
|
|
|
data[pixel * 4 + 1] = current;
|
|
|
data[pixel * 4 + 2] = current;
|
|
|
data[pixel * 4 + 3] = 255;
|
|
|
}
|
|
|
}
|
|
|
frame.data = data;
|
|
|
ctx.putImageData(frame, 0, 0);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Retrieves a given pixel position from the {SubImage}
|
|
|
* @param x {Number} The x-position
|
|
|
* @param y {Number} The y-position
|
|
|
* @returns {Number} The grayscale value at the pixel-position
|
|
|
*/
|
|
|
SubImage.prototype.get = function (x, y) {
|
|
|
return this.data[(this.from.y + y) * this.originalSize.x + this.from.x + x];
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Updates the underlying data from a given {ImageWrapper}
|
|
|
* @param image {ImageWrapper} The updated image
|
|
|
*/
|
|
|
SubImage.prototype.updateData = function (image) {
|
|
|
this.originalSize = image.size;
|
|
|
this.data = image.data;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Updates the position of the shared area
|
|
|
* @param from {x,y} The new location
|
|
|
* @returns {SubImage} returns {this} for possible chaining
|
|
|
*/
|
|
|
SubImage.prototype.updateFrom = function (from) {
|
|
|
this.from = from;
|
|
|
return this;
|
|
|
};
|
|
|
|
|
|
exports.default = SubImage;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 79 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
/*
|
|
|
* typedefs.js
|
|
|
* Normalizes browser-specific prefixes
|
|
|
*/
|
|
|
|
|
|
if (typeof window !== 'undefined') {
|
|
|
window.requestAnimFrame = function () {
|
|
|
return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function ( /* function FrameRequestCallback */callback) {
|
|
|
window.setTimeout(callback, 1000 / 60);
|
|
|
};
|
|
|
}();
|
|
|
}
|
|
|
Math.imul = Math.imul || function (a, b) {
|
|
|
var ah = a >>> 16 & 0xffff,
|
|
|
al = a & 0xffff,
|
|
|
bh = b >>> 16 & 0xffff,
|
|
|
bl = b & 0xffff;
|
|
|
// the shift by 0 fixes the sign on the high part
|
|
|
// the final |0 converts the unsigned value into a signed value
|
|
|
return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0;
|
|
|
};
|
|
|
|
|
|
if (typeof Object.assign !== 'function') {
|
|
|
Object.assign = function (target) {
|
|
|
// .length of function is 2
|
|
|
'use strict';
|
|
|
|
|
|
if (target === null) {
|
|
|
// TypeError if undefined or null
|
|
|
throw new TypeError('Cannot convert undefined or null to object');
|
|
|
}
|
|
|
|
|
|
var to = Object(target);
|
|
|
|
|
|
for (var index = 1; index < arguments.length; index++) {
|
|
|
var nextSource = arguments[index];
|
|
|
|
|
|
if (nextSource !== null) {
|
|
|
// Skip over if undefined or null
|
|
|
for (var nextKey in nextSource) {
|
|
|
// Avoid bugs when hasOwnProperty is shadowed
|
|
|
if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
|
|
|
to[nextKey] = nextSource[nextKey];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return to;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 80 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
var config = void 0;
|
|
|
|
|
|
if (false) {
|
|
|
config = require('./config.dev.js');
|
|
|
} else if (true) {
|
|
|
config = __webpack_require__(81);
|
|
|
} else {
|
|
|
config = require('./config.prod.js');
|
|
|
}
|
|
|
|
|
|
exports.default = config;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 81 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
module.exports = {
|
|
|
inputStream: {
|
|
|
type: "ImageStream",
|
|
|
sequence: false,
|
|
|
size: 800,
|
|
|
area: {
|
|
|
top: "0%",
|
|
|
right: "0%",
|
|
|
left: "0%",
|
|
|
bottom: "0%"
|
|
|
},
|
|
|
singleChannel: false // true: only the red color-channel is read
|
|
|
},
|
|
|
locate: true,
|
|
|
numOfWorkers: 0,
|
|
|
decoder: {
|
|
|
readers: ['code_128_reader']
|
|
|
},
|
|
|
locator: {
|
|
|
halfSample: true,
|
|
|
patchSize: "medium" // x-small, small, medium, large, x-large
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 82 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
|
|
var _bresenham = __webpack_require__(83);
|
|
|
|
|
|
var _bresenham2 = _interopRequireDefault(_bresenham);
|
|
|
|
|
|
var _image_debug = __webpack_require__(14);
|
|
|
|
|
|
var _image_debug2 = _interopRequireDefault(_image_debug);
|
|
|
|
|
|
var _code_128_reader = __webpack_require__(89);
|
|
|
|
|
|
var _code_128_reader2 = _interopRequireDefault(_code_128_reader);
|
|
|
|
|
|
var _ean_reader = __webpack_require__(5);
|
|
|
|
|
|
var _ean_reader2 = _interopRequireDefault(_ean_reader);
|
|
|
|
|
|
var _code_39_reader = __webpack_require__(43);
|
|
|
|
|
|
var _code_39_reader2 = _interopRequireDefault(_code_39_reader);
|
|
|
|
|
|
var _code_39_vin_reader = __webpack_require__(90);
|
|
|
|
|
|
var _code_39_vin_reader2 = _interopRequireDefault(_code_39_vin_reader);
|
|
|
|
|
|
var _codabar_reader = __webpack_require__(88);
|
|
|
|
|
|
var _codabar_reader2 = _interopRequireDefault(_codabar_reader);
|
|
|
|
|
|
var _upc_reader = __webpack_require__(96);
|
|
|
|
|
|
var _upc_reader2 = _interopRequireDefault(_upc_reader);
|
|
|
|
|
|
var _ean_8_reader = __webpack_require__(93);
|
|
|
|
|
|
var _ean_8_reader2 = _interopRequireDefault(_ean_8_reader);
|
|
|
|
|
|
var _ean_2_reader = __webpack_require__(91);
|
|
|
|
|
|
var _ean_2_reader2 = _interopRequireDefault(_ean_2_reader);
|
|
|
|
|
|
var _ean_5_reader = __webpack_require__(92);
|
|
|
|
|
|
var _ean_5_reader2 = _interopRequireDefault(_ean_5_reader);
|
|
|
|
|
|
var _upc_e_reader = __webpack_require__(95);
|
|
|
|
|
|
var _upc_e_reader2 = _interopRequireDefault(_upc_e_reader);
|
|
|
|
|
|
var _i2of5_reader = __webpack_require__(94);
|
|
|
|
|
|
var _i2of5_reader2 = _interopRequireDefault(_i2of5_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var READERS = {
|
|
|
code_128_reader: _code_128_reader2.default,
|
|
|
ean_reader: _ean_reader2.default,
|
|
|
ean_5_reader: _ean_5_reader2.default,
|
|
|
ean_2_reader: _ean_2_reader2.default,
|
|
|
ean_8_reader: _ean_8_reader2.default,
|
|
|
code_39_reader: _code_39_reader2.default,
|
|
|
code_39_vin_reader: _code_39_vin_reader2.default,
|
|
|
codabar_reader: _codabar_reader2.default,
|
|
|
upc_reader: _upc_reader2.default,
|
|
|
upc_e_reader: _upc_e_reader2.default,
|
|
|
i2of5_reader: _i2of5_reader2.default
|
|
|
};
|
|
|
exports.default = {
|
|
|
create: function create(config, inputImageWrapper) {
|
|
|
var _canvas = {
|
|
|
ctx: {
|
|
|
frequency: null,
|
|
|
pattern: null,
|
|
|
overlay: null
|
|
|
},
|
|
|
dom: {
|
|
|
frequency: null,
|
|
|
pattern: null,
|
|
|
overlay: null
|
|
|
}
|
|
|
},
|
|
|
_barcodeReaders = [];
|
|
|
|
|
|
initCanvas();
|
|
|
initReaders();
|
|
|
initConfig();
|
|
|
|
|
|
function initCanvas() {
|
|
|
if (false) {
|
|
|
var $debug = document.querySelector("#debug.detection");
|
|
|
_canvas.dom.frequency = document.querySelector("canvas.frequency");
|
|
|
if (!_canvas.dom.frequency) {
|
|
|
_canvas.dom.frequency = document.createElement("canvas");
|
|
|
_canvas.dom.frequency.className = "frequency";
|
|
|
if ($debug) {
|
|
|
$debug.appendChild(_canvas.dom.frequency);
|
|
|
}
|
|
|
}
|
|
|
_canvas.ctx.frequency = _canvas.dom.frequency.getContext("2d");
|
|
|
|
|
|
_canvas.dom.pattern = document.querySelector("canvas.patternBuffer");
|
|
|
if (!_canvas.dom.pattern) {
|
|
|
_canvas.dom.pattern = document.createElement("canvas");
|
|
|
_canvas.dom.pattern.className = "patternBuffer";
|
|
|
if ($debug) {
|
|
|
$debug.appendChild(_canvas.dom.pattern);
|
|
|
}
|
|
|
}
|
|
|
_canvas.ctx.pattern = _canvas.dom.pattern.getContext("2d");
|
|
|
|
|
|
_canvas.dom.overlay = document.querySelector("canvas.drawingBuffer");
|
|
|
if (_canvas.dom.overlay) {
|
|
|
_canvas.ctx.overlay = _canvas.dom.overlay.getContext("2d");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function initReaders() {
|
|
|
config.readers.forEach(function (readerConfig) {
|
|
|
var reader,
|
|
|
configuration = {},
|
|
|
supplements = [];
|
|
|
|
|
|
if ((typeof readerConfig === 'undefined' ? 'undefined' : _typeof(readerConfig)) === 'object') {
|
|
|
reader = readerConfig.format;
|
|
|
configuration = readerConfig.config;
|
|
|
} else if (typeof readerConfig === 'string') {
|
|
|
reader = readerConfig;
|
|
|
}
|
|
|
if (false) {
|
|
|
console.log("Before registering reader: ", reader);
|
|
|
}
|
|
|
if (configuration.supplements) {
|
|
|
supplements = configuration.supplements.map(function (supplement) {
|
|
|
return new READERS[supplement]();
|
|
|
});
|
|
|
}
|
|
|
_barcodeReaders.push(new READERS[reader](configuration, supplements));
|
|
|
});
|
|
|
if (false) {
|
|
|
console.log("Registered Readers: " + _barcodeReaders.map(function (reader) {
|
|
|
return JSON.stringify({ format: reader.FORMAT, config: reader.config });
|
|
|
}).join(', '));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function initConfig() {
|
|
|
if (false) {
|
|
|
var i,
|
|
|
vis = [{
|
|
|
node: _canvas.dom.frequency,
|
|
|
prop: config.debug.showFrequency
|
|
|
}, {
|
|
|
node: _canvas.dom.pattern,
|
|
|
prop: config.debug.showPattern
|
|
|
}];
|
|
|
|
|
|
for (i = 0; i < vis.length; i++) {
|
|
|
if (vis[i].prop === true) {
|
|
|
vis[i].node.style.display = "block";
|
|
|
} else {
|
|
|
vis[i].node.style.display = "none";
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* extend the line on both ends
|
|
|
* @param {Array} line
|
|
|
* @param {Number} angle
|
|
|
*/
|
|
|
function getExtendedLine(line, angle, ext) {
|
|
|
function extendLine(amount) {
|
|
|
var extension = {
|
|
|
y: amount * Math.sin(angle),
|
|
|
x: amount * Math.cos(angle)
|
|
|
};
|
|
|
|
|
|
line[0].y -= extension.y;
|
|
|
line[0].x -= extension.x;
|
|
|
line[1].y += extension.y;
|
|
|
line[1].x += extension.x;
|
|
|
}
|
|
|
|
|
|
// check if inside image
|
|
|
extendLine(ext);
|
|
|
while (ext > 1 && (!inputImageWrapper.inImageWithBorder(line[0], 0) || !inputImageWrapper.inImageWithBorder(line[1], 0))) {
|
|
|
ext -= Math.ceil(ext / 2);
|
|
|
extendLine(-ext);
|
|
|
}
|
|
|
return line;
|
|
|
}
|
|
|
|
|
|
function getLine(box) {
|
|
|
return [{
|
|
|
x: (box[1][0] - box[0][0]) / 2 + box[0][0],
|
|
|
y: (box[1][1] - box[0][1]) / 2 + box[0][1]
|
|
|
}, {
|
|
|
x: (box[3][0] - box[2][0]) / 2 + box[2][0],
|
|
|
y: (box[3][1] - box[2][1]) / 2 + box[2][1]
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
function tryDecode(line) {
|
|
|
var result = null,
|
|
|
i,
|
|
|
barcodeLine = _bresenham2.default.getBarcodeLine(inputImageWrapper, line[0], line[1]);
|
|
|
|
|
|
if (false) {
|
|
|
_image_debug2.default.drawPath(line, { x: 'x', y: 'y' }, _canvas.ctx.overlay, { color: 'red', lineWidth: 3 });
|
|
|
_bresenham2.default.debug.printFrequency(barcodeLine.line, _canvas.dom.frequency);
|
|
|
}
|
|
|
|
|
|
_bresenham2.default.toBinaryLine(barcodeLine);
|
|
|
|
|
|
if (false) {
|
|
|
_bresenham2.default.debug.printPattern(barcodeLine.line, _canvas.dom.pattern);
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < _barcodeReaders.length && result === null; i++) {
|
|
|
result = _barcodeReaders[i].decodePattern(barcodeLine.line);
|
|
|
}
|
|
|
if (result === null) {
|
|
|
return null;
|
|
|
}
|
|
|
return {
|
|
|
codeResult: result,
|
|
|
barcodeLine: barcodeLine
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* This method slices the given area apart and tries to detect a barcode-pattern
|
|
|
* for each slice. It returns the decoded barcode, or null if nothing was found
|
|
|
* @param {Array} box
|
|
|
* @param {Array} line
|
|
|
* @param {Number} lineAngle
|
|
|
*/
|
|
|
function tryDecodeBruteForce(box, line, lineAngle) {
|
|
|
var sideLength = Math.sqrt(Math.pow(box[1][0] - box[0][0], 2) + Math.pow(box[1][1] - box[0][1], 2)),
|
|
|
i,
|
|
|
slices = 16,
|
|
|
result = null,
|
|
|
dir,
|
|
|
extension,
|
|
|
xdir = Math.sin(lineAngle),
|
|
|
ydir = Math.cos(lineAngle);
|
|
|
|
|
|
for (i = 1; i < slices && result === null; i++) {
|
|
|
// move line perpendicular to angle
|
|
|
dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);
|
|
|
extension = {
|
|
|
y: dir * xdir,
|
|
|
x: dir * ydir
|
|
|
};
|
|
|
line[0].y += extension.x;
|
|
|
line[0].x -= extension.y;
|
|
|
line[1].y += extension.x;
|
|
|
line[1].x -= extension.y;
|
|
|
|
|
|
result = tryDecode(line);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
function getLineLength(line) {
|
|
|
return Math.sqrt(Math.pow(Math.abs(line[1].y - line[0].y), 2) + Math.pow(Math.abs(line[1].x - line[0].x), 2));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* With the help of the configured readers (Code128 or EAN) this function tries to detect a
|
|
|
* valid barcode pattern within the given area.
|
|
|
* @param {Object} box The area to search in
|
|
|
* @returns {Object} the result {codeResult, line, angle, pattern, threshold}
|
|
|
*/
|
|
|
function _decodeFromBoundingBox(box) {
|
|
|
var line,
|
|
|
lineAngle,
|
|
|
ctx = _canvas.ctx.overlay,
|
|
|
result,
|
|
|
lineLength;
|
|
|
|
|
|
if (false) {
|
|
|
if (config.debug.drawBoundingBox && ctx) {
|
|
|
_image_debug2.default.drawPath(box, { x: 0, y: 1 }, ctx, { color: "blue", lineWidth: 2 });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
line = getLine(box);
|
|
|
lineLength = getLineLength(line);
|
|
|
lineAngle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);
|
|
|
line = getExtendedLine(line, lineAngle, Math.floor(lineLength * 0.1));
|
|
|
if (line === null) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
result = tryDecode(line);
|
|
|
if (result === null) {
|
|
|
result = tryDecodeBruteForce(box, line, lineAngle);
|
|
|
}
|
|
|
|
|
|
if (result === null) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (false) {
|
|
|
_image_debug2.default.drawPath(line, { x: 'x', y: 'y' }, ctx, { color: 'red', lineWidth: 3 });
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
codeResult: result.codeResult,
|
|
|
line: line,
|
|
|
angle: lineAngle,
|
|
|
pattern: result.barcodeLine.line,
|
|
|
threshold: result.barcodeLine.threshold
|
|
|
};
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
decodeFromBoundingBox: function decodeFromBoundingBox(box) {
|
|
|
return _decodeFromBoundingBox(box);
|
|
|
},
|
|
|
decodeFromBoundingBoxes: function decodeFromBoundingBoxes(boxes) {
|
|
|
var i,
|
|
|
result,
|
|
|
barcodes = [],
|
|
|
multiple = config.multiple;
|
|
|
|
|
|
for (i = 0; i < boxes.length; i++) {
|
|
|
var box = boxes[i];
|
|
|
result = _decodeFromBoundingBox(box) || {};
|
|
|
result.box = box;
|
|
|
|
|
|
if (multiple) {
|
|
|
barcodes.push(result);
|
|
|
} else if (result.codeResult) {
|
|
|
return result;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (multiple) {
|
|
|
return {
|
|
|
barcodes: barcodes
|
|
|
};
|
|
|
}
|
|
|
},
|
|
|
setReaders: function setReaders(readers) {
|
|
|
config.readers = readers;
|
|
|
_barcodeReaders.length = 0;
|
|
|
initReaders();
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 83 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _image_wrapper = __webpack_require__(26);
|
|
|
|
|
|
var _image_wrapper2 = _interopRequireDefault(_image_wrapper);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var Bresenham = {};
|
|
|
|
|
|
var Slope = {
|
|
|
DIR: {
|
|
|
UP: 1,
|
|
|
DOWN: -1
|
|
|
}
|
|
|
};
|
|
|
/**
|
|
|
* Scans a line of the given image from point p1 to p2 and returns a result object containing
|
|
|
* gray-scale values (0-255) of the underlying pixels in addition to the min
|
|
|
* and max values.
|
|
|
* @param {Object} imageWrapper
|
|
|
* @param {Object} p1 The start point {x,y}
|
|
|
* @param {Object} p2 The end point {x,y}
|
|
|
* @returns {line, min, max}
|
|
|
*/
|
|
|
Bresenham.getBarcodeLine = function (imageWrapper, p1, p2) {
|
|
|
var x0 = p1.x | 0,
|
|
|
y0 = p1.y | 0,
|
|
|
x1 = p2.x | 0,
|
|
|
y1 = p2.y | 0,
|
|
|
steep = Math.abs(y1 - y0) > Math.abs(x1 - x0),
|
|
|
deltax,
|
|
|
deltay,
|
|
|
error,
|
|
|
ystep,
|
|
|
y,
|
|
|
tmp,
|
|
|
x,
|
|
|
line = [],
|
|
|
imageData = imageWrapper.data,
|
|
|
width = imageWrapper.size.x,
|
|
|
sum = 0,
|
|
|
val,
|
|
|
min = 255,
|
|
|
max = 0;
|
|
|
|
|
|
function read(a, b) {
|
|
|
val = imageData[b * width + a];
|
|
|
sum += val;
|
|
|
min = val < min ? val : min;
|
|
|
max = val > max ? val : max;
|
|
|
line.push(val);
|
|
|
}
|
|
|
|
|
|
if (steep) {
|
|
|
tmp = x0;
|
|
|
x0 = y0;
|
|
|
y0 = tmp;
|
|
|
|
|
|
tmp = x1;
|
|
|
x1 = y1;
|
|
|
y1 = tmp;
|
|
|
}
|
|
|
if (x0 > x1) {
|
|
|
tmp = x0;
|
|
|
x0 = x1;
|
|
|
x1 = tmp;
|
|
|
|
|
|
tmp = y0;
|
|
|
y0 = y1;
|
|
|
y1 = tmp;
|
|
|
}
|
|
|
deltax = x1 - x0;
|
|
|
deltay = Math.abs(y1 - y0);
|
|
|
error = deltax / 2 | 0;
|
|
|
y = y0;
|
|
|
ystep = y0 < y1 ? 1 : -1;
|
|
|
for (x = x0; x < x1; x++) {
|
|
|
if (steep) {
|
|
|
read(y, x);
|
|
|
} else {
|
|
|
read(x, y);
|
|
|
}
|
|
|
error = error - deltay;
|
|
|
if (error < 0) {
|
|
|
y = y + ystep;
|
|
|
error = error + deltax;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
line: line,
|
|
|
min: min,
|
|
|
max: max
|
|
|
};
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Converts the result from getBarcodeLine into a binary representation
|
|
|
* also considering the frequency and slope of the signal for more robust results
|
|
|
* @param {Object} result {line, min, max}
|
|
|
*/
|
|
|
Bresenham.toBinaryLine = function (result) {
|
|
|
var min = result.min,
|
|
|
max = result.max,
|
|
|
line = result.line,
|
|
|
slope,
|
|
|
slope2,
|
|
|
center = min + (max - min) / 2,
|
|
|
extrema = [],
|
|
|
currentDir,
|
|
|
dir,
|
|
|
threshold = (max - min) / 12,
|
|
|
rThreshold = -threshold,
|
|
|
i,
|
|
|
j;
|
|
|
|
|
|
// 1. find extrema
|
|
|
currentDir = line[0] > center ? Slope.DIR.UP : Slope.DIR.DOWN;
|
|
|
extrema.push({
|
|
|
pos: 0,
|
|
|
val: line[0]
|
|
|
});
|
|
|
for (i = 0; i < line.length - 2; i++) {
|
|
|
slope = line[i + 1] - line[i];
|
|
|
slope2 = line[i + 2] - line[i + 1];
|
|
|
if (slope + slope2 < rThreshold && line[i + 1] < center * 1.5) {
|
|
|
dir = Slope.DIR.DOWN;
|
|
|
} else if (slope + slope2 > threshold && line[i + 1] > center * 0.5) {
|
|
|
dir = Slope.DIR.UP;
|
|
|
} else {
|
|
|
dir = currentDir;
|
|
|
}
|
|
|
|
|
|
if (currentDir !== dir) {
|
|
|
extrema.push({
|
|
|
pos: i,
|
|
|
val: line[i]
|
|
|
});
|
|
|
currentDir = dir;
|
|
|
}
|
|
|
}
|
|
|
extrema.push({
|
|
|
pos: line.length,
|
|
|
val: line[line.length - 1]
|
|
|
});
|
|
|
|
|
|
for (j = extrema[0].pos; j < extrema[1].pos; j++) {
|
|
|
line[j] = line[j] > center ? 0 : 1;
|
|
|
}
|
|
|
|
|
|
// iterate over extrema and convert to binary based on avg between minmax
|
|
|
for (i = 1; i < extrema.length - 1; i++) {
|
|
|
if (extrema[i + 1].val > extrema[i].val) {
|
|
|
threshold = extrema[i].val + (extrema[i + 1].val - extrema[i].val) / 3 * 2 | 0;
|
|
|
} else {
|
|
|
threshold = extrema[i + 1].val + (extrema[i].val - extrema[i + 1].val) / 3 | 0;
|
|
|
}
|
|
|
|
|
|
for (j = extrema[i].pos; j < extrema[i + 1].pos; j++) {
|
|
|
line[j] = line[j] > threshold ? 0 : 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
line: line,
|
|
|
threshold: threshold
|
|
|
};
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Used for development only
|
|
|
*/
|
|
|
Bresenham.debug = {
|
|
|
printFrequency: function printFrequency(line, canvas) {
|
|
|
var i,
|
|
|
ctx = canvas.getContext("2d");
|
|
|
canvas.width = line.length;
|
|
|
canvas.height = 256;
|
|
|
|
|
|
ctx.beginPath();
|
|
|
ctx.strokeStyle = "blue";
|
|
|
for (i = 0; i < line.length; i++) {
|
|
|
ctx.moveTo(i, 255);
|
|
|
ctx.lineTo(i, 255 - line[i]);
|
|
|
}
|
|
|
ctx.stroke();
|
|
|
ctx.closePath();
|
|
|
},
|
|
|
|
|
|
printPattern: function printPattern(line, canvas) {
|
|
|
var ctx = canvas.getContext("2d"),
|
|
|
i;
|
|
|
|
|
|
canvas.width = line.length;
|
|
|
ctx.fillColor = "black";
|
|
|
for (i = 0; i < line.length; i++) {
|
|
|
if (line[i] === 1) {
|
|
|
ctx.fillRect(i, 0, 1, 100);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = Bresenham;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 84 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _pick2 = __webpack_require__(198);
|
|
|
|
|
|
var _pick3 = _interopRequireDefault(_pick2);
|
|
|
|
|
|
var _omit2 = __webpack_require__(197);
|
|
|
|
|
|
var _omit3 = _interopRequireDefault(_omit2);
|
|
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
|
|
exports.pickConstraints = pickConstraints;
|
|
|
|
|
|
var _mediaDevices = __webpack_require__(77);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var facingMatching = {
|
|
|
"user": /front/i,
|
|
|
"environment": /back/i
|
|
|
};
|
|
|
|
|
|
var streamRef;
|
|
|
|
|
|
function waitForVideo(video) {
|
|
|
return new Promise(function (resolve, reject) {
|
|
|
var attempts = 10;
|
|
|
|
|
|
function checkVideo() {
|
|
|
if (attempts > 0) {
|
|
|
if (video.videoWidth > 0 && video.videoHeight > 0) {
|
|
|
if (false) {
|
|
|
console.log(video.videoWidth + "px x " + video.videoHeight + "px");
|
|
|
}
|
|
|
resolve();
|
|
|
} else {
|
|
|
window.setTimeout(checkVideo, 500);
|
|
|
}
|
|
|
} else {
|
|
|
reject('Unable to play video stream. Is webcam working?');
|
|
|
}
|
|
|
attempts--;
|
|
|
}
|
|
|
checkVideo();
|
|
|
});
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Tries to attach the camera-stream to a given video-element
|
|
|
* and calls the callback function when the content is ready
|
|
|
* @param {Object} constraints
|
|
|
* @param {Object} video
|
|
|
*/
|
|
|
function initCamera(video, constraints) {
|
|
|
return (0, _mediaDevices.getUserMedia)(constraints).then(function (stream) {
|
|
|
return new Promise(function (resolve) {
|
|
|
streamRef = stream;
|
|
|
video.setAttribute("autoplay", 'true');
|
|
|
video.srcObject = stream;
|
|
|
video.addEventListener('loadedmetadata', function () {
|
|
|
video.play();
|
|
|
resolve();
|
|
|
});
|
|
|
});
|
|
|
}).then(waitForVideo.bind(null, video));
|
|
|
}
|
|
|
|
|
|
function deprecatedConstraints(videoConstraints) {
|
|
|
var normalized = (0, _pick3.default)(videoConstraints, ["width", "height", "facingMode", "aspectRatio", "deviceId"]);
|
|
|
|
|
|
if (typeof videoConstraints.minAspectRatio !== 'undefined' && videoConstraints.minAspectRatio > 0) {
|
|
|
normalized.aspectRatio = videoConstraints.minAspectRatio;
|
|
|
console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead");
|
|
|
}
|
|
|
if (typeof videoConstraints.facing !== 'undefined') {
|
|
|
normalized.facingMode = videoConstraints.facing;
|
|
|
console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'");
|
|
|
}
|
|
|
return normalized;
|
|
|
}
|
|
|
|
|
|
function pickDevice(constraints) {
|
|
|
var desiredFacing = constraints.video.facingMode,
|
|
|
facingMatch = facingMatching[desiredFacing];
|
|
|
|
|
|
if (!facingMatch) {
|
|
|
return Promise.resolve(constraints);
|
|
|
}
|
|
|
return (0, _mediaDevices.enumerateDevices)().then(function (devices) {
|
|
|
var selectedDeviceId = devices.filter(function (device) {
|
|
|
return device.kind === 'videoinput' && facingMatch.test(device.label);
|
|
|
}).map(function (facingDevice) {
|
|
|
return facingDevice.deviceId;
|
|
|
})[0];
|
|
|
if (selectedDeviceId) {
|
|
|
constraints = _extends({}, constraints, {
|
|
|
video: _extends({}, (0, _omit3.default)(constraints.video, ["facingMode"]), {
|
|
|
deviceId: selectedDeviceId
|
|
|
})
|
|
|
});
|
|
|
}
|
|
|
return Promise.resolve(constraints);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
function pickConstraints(videoConstraints) {
|
|
|
var normalizedConstraints = {
|
|
|
audio: false,
|
|
|
video: deprecatedConstraints(videoConstraints)
|
|
|
};
|
|
|
|
|
|
if (!normalizedConstraints.video.deviceId) {
|
|
|
if (typeof normalizedConstraints.video.facingMode === 'string' && normalizedConstraints.video.facingMode.length > 0) {
|
|
|
return pickDevice(normalizedConstraints);
|
|
|
}
|
|
|
}
|
|
|
return Promise.resolve(normalizedConstraints);
|
|
|
}
|
|
|
|
|
|
function enumerateVideoDevices() {
|
|
|
return (0, _mediaDevices.enumerateDevices)().then(function (devices) {
|
|
|
return devices.filter(function (device) {
|
|
|
return device.kind === 'videoinput';
|
|
|
});
|
|
|
});
|
|
|
}
|
|
|
|
|
|
exports.default = {
|
|
|
request: function request(video, videoConstraints) {
|
|
|
return pickConstraints(videoConstraints).then(initCamera.bind(null, video));
|
|
|
},
|
|
|
release: function release() {
|
|
|
var tracks = streamRef && streamRef.getVideoTracks();
|
|
|
if (tracks && tracks.length) {
|
|
|
tracks[0].stop();
|
|
|
}
|
|
|
streamRef = null;
|
|
|
},
|
|
|
enumerateVideoDevices: enumerateVideoDevices,
|
|
|
getActiveStreamLabel: function getActiveStreamLabel() {
|
|
|
if (streamRef) {
|
|
|
var tracks = streamRef.getVideoTracks();
|
|
|
if (tracks && tracks.length) {
|
|
|
return tracks[0].label;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 85 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _image_wrapper = __webpack_require__(26);
|
|
|
|
|
|
var _image_wrapper2 = _interopRequireDefault(_image_wrapper);
|
|
|
|
|
|
var _cv_utils = __webpack_require__(25);
|
|
|
|
|
|
var _array_helper = __webpack_require__(13);
|
|
|
|
|
|
var _array_helper2 = _interopRequireDefault(_array_helper);
|
|
|
|
|
|
var _image_debug = __webpack_require__(14);
|
|
|
|
|
|
var _image_debug2 = _interopRequireDefault(_image_debug);
|
|
|
|
|
|
var _rasterizer = __webpack_require__(86);
|
|
|
|
|
|
var _rasterizer2 = _interopRequireDefault(_rasterizer);
|
|
|
|
|
|
var _tracer = __webpack_require__(42);
|
|
|
|
|
|
var _tracer2 = _interopRequireDefault(_tracer);
|
|
|
|
|
|
var _skeletonizer2 = __webpack_require__(87);
|
|
|
|
|
|
var _skeletonizer3 = _interopRequireDefault(_skeletonizer2);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
var vec2 = {
|
|
|
clone: __webpack_require__(11),
|
|
|
dot: __webpack_require__(44),
|
|
|
scale: __webpack_require__(100),
|
|
|
transformMat2: __webpack_require__(101)
|
|
|
};
|
|
|
var mat2 = {
|
|
|
copy: __webpack_require__(97),
|
|
|
create: __webpack_require__(98),
|
|
|
invert: __webpack_require__(99)
|
|
|
};
|
|
|
|
|
|
var _config,
|
|
|
_currentImageWrapper,
|
|
|
_skelImageWrapper,
|
|
|
_subImageWrapper,
|
|
|
_labelImageWrapper,
|
|
|
_patchGrid,
|
|
|
_patchLabelGrid,
|
|
|
_imageToPatchGrid,
|
|
|
_binaryImageWrapper,
|
|
|
_patchSize,
|
|
|
_canvasContainer = {
|
|
|
ctx: {
|
|
|
binary: null
|
|
|
},
|
|
|
dom: {
|
|
|
binary: null
|
|
|
}
|
|
|
},
|
|
|
_numPatches = { x: 0, y: 0 },
|
|
|
_inputImageWrapper,
|
|
|
_skeletonizer;
|
|
|
|
|
|
function initBuffers() {
|
|
|
var skeletonImageData;
|
|
|
|
|
|
if (_config.halfSample) {
|
|
|
_currentImageWrapper = new _image_wrapper2.default({
|
|
|
x: _inputImageWrapper.size.x / 2 | 0,
|
|
|
y: _inputImageWrapper.size.y / 2 | 0
|
|
|
});
|
|
|
} else {
|
|
|
_currentImageWrapper = _inputImageWrapper;
|
|
|
}
|
|
|
|
|
|
_patchSize = (0, _cv_utils.calculatePatchSize)(_config.patchSize, _currentImageWrapper.size);
|
|
|
|
|
|
_numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0;
|
|
|
_numPatches.y = _currentImageWrapper.size.y / _patchSize.y | 0;
|
|
|
|
|
|
_binaryImageWrapper = new _image_wrapper2.default(_currentImageWrapper.size, undefined, Uint8Array, false);
|
|
|
|
|
|
_labelImageWrapper = new _image_wrapper2.default(_patchSize, undefined, Array, true);
|
|
|
|
|
|
skeletonImageData = new ArrayBuffer(64 * 1024);
|
|
|
_subImageWrapper = new _image_wrapper2.default(_patchSize, new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y));
|
|
|
_skelImageWrapper = new _image_wrapper2.default(_patchSize, new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y), undefined, true);
|
|
|
_skeletonizer = (0, _skeletonizer3.default)(typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : global, {
|
|
|
size: _patchSize.x
|
|
|
}, skeletonImageData);
|
|
|
|
|
|
_imageToPatchGrid = new _image_wrapper2.default({
|
|
|
x: _currentImageWrapper.size.x / _subImageWrapper.size.x | 0,
|
|
|
y: _currentImageWrapper.size.y / _subImageWrapper.size.y | 0
|
|
|
}, undefined, Array, true);
|
|
|
_patchGrid = new _image_wrapper2.default(_imageToPatchGrid.size, undefined, undefined, true);
|
|
|
_patchLabelGrid = new _image_wrapper2.default(_imageToPatchGrid.size, undefined, Int32Array, true);
|
|
|
}
|
|
|
|
|
|
function initCanvas() {
|
|
|
if (_config.useWorker || typeof document === 'undefined') {
|
|
|
return;
|
|
|
}
|
|
|
_canvasContainer.dom.binary = document.createElement("canvas");
|
|
|
_canvasContainer.dom.binary.className = "binaryBuffer";
|
|
|
if (false) {
|
|
|
document.querySelector("#debug").appendChild(_canvasContainer.dom.binary);
|
|
|
}
|
|
|
_canvasContainer.ctx.binary = _canvasContainer.dom.binary.getContext("2d");
|
|
|
_canvasContainer.dom.binary.width = _binaryImageWrapper.size.x;
|
|
|
_canvasContainer.dom.binary.height = _binaryImageWrapper.size.y;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Creates a bounding box which encloses all the given patches
|
|
|
* @returns {Array} The minimal bounding box
|
|
|
*/
|
|
|
function boxFromPatches(patches) {
|
|
|
var overAvg,
|
|
|
i,
|
|
|
j,
|
|
|
patch,
|
|
|
transMat,
|
|
|
minx = _binaryImageWrapper.size.x,
|
|
|
miny = _binaryImageWrapper.size.y,
|
|
|
maxx = -_binaryImageWrapper.size.x,
|
|
|
maxy = -_binaryImageWrapper.size.y,
|
|
|
box,
|
|
|
scale;
|
|
|
|
|
|
// draw all patches which are to be taken into consideration
|
|
|
overAvg = 0;
|
|
|
for (i = 0; i < patches.length; i++) {
|
|
|
patch = patches[i];
|
|
|
overAvg += patch.rad;
|
|
|
if (false) {
|
|
|
_image_debug2.default.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "red" });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
overAvg /= patches.length;
|
|
|
overAvg = (overAvg * 180 / Math.PI + 90) % 180 - 90;
|
|
|
if (overAvg < 0) {
|
|
|
overAvg += 180;
|
|
|
}
|
|
|
|
|
|
overAvg = (180 - overAvg) * Math.PI / 180;
|
|
|
transMat = mat2.copy(mat2.create(), [Math.cos(overAvg), Math.sin(overAvg), -Math.sin(overAvg), Math.cos(overAvg)]);
|
|
|
|
|
|
// iterate over patches and rotate by angle
|
|
|
for (i = 0; i < patches.length; i++) {
|
|
|
patch = patches[i];
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
vec2.transformMat2(patch.box[j], patch.box[j], transMat);
|
|
|
}
|
|
|
|
|
|
if (false) {
|
|
|
_image_debug2.default.drawPath(patch.box, { x: 0, y: 1 }, _canvasContainer.ctx.binary, { color: '#99ff00', lineWidth: 2 });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// find bounding box
|
|
|
for (i = 0; i < patches.length; i++) {
|
|
|
patch = patches[i];
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
if (patch.box[j][0] < minx) {
|
|
|
minx = patch.box[j][0];
|
|
|
}
|
|
|
if (patch.box[j][0] > maxx) {
|
|
|
maxx = patch.box[j][0];
|
|
|
}
|
|
|
if (patch.box[j][1] < miny) {
|
|
|
miny = patch.box[j][1];
|
|
|
}
|
|
|
if (patch.box[j][1] > maxy) {
|
|
|
maxy = patch.box[j][1];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
box = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]];
|
|
|
|
|
|
if (false) {
|
|
|
_image_debug2.default.drawPath(box, { x: 0, y: 1 }, _canvasContainer.ctx.binary, { color: '#ff0000', lineWidth: 2 });
|
|
|
}
|
|
|
|
|
|
scale = _config.halfSample ? 2 : 1;
|
|
|
// reverse rotation;
|
|
|
transMat = mat2.invert(transMat, transMat);
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
vec2.transformMat2(box[j], box[j], transMat);
|
|
|
}
|
|
|
|
|
|
if (false) {
|
|
|
_image_debug2.default.drawPath(box, { x: 0, y: 1 }, _canvasContainer.ctx.binary, { color: '#ff0000', lineWidth: 2 });
|
|
|
}
|
|
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
vec2.scale(box[j], box[j], scale);
|
|
|
}
|
|
|
|
|
|
return box;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Creates a binary image of the current image
|
|
|
*/
|
|
|
function binarizeImage() {
|
|
|
(0, _cv_utils.otsuThreshold)(_currentImageWrapper, _binaryImageWrapper);
|
|
|
_binaryImageWrapper.zeroBorder();
|
|
|
if (false) {
|
|
|
_binaryImageWrapper.show(_canvasContainer.dom.binary, 255);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Iterate over the entire image
|
|
|
* extract patches
|
|
|
*/
|
|
|
function findPatches() {
|
|
|
var i,
|
|
|
j,
|
|
|
x,
|
|
|
y,
|
|
|
moments,
|
|
|
patchesFound = [],
|
|
|
rasterizer,
|
|
|
rasterResult,
|
|
|
patch;
|
|
|
for (i = 0; i < _numPatches.x; i++) {
|
|
|
for (j = 0; j < _numPatches.y; j++) {
|
|
|
x = _subImageWrapper.size.x * i;
|
|
|
y = _subImageWrapper.size.y * j;
|
|
|
|
|
|
// seperate parts
|
|
|
skeletonize(x, y);
|
|
|
|
|
|
// Rasterize, find individual bars
|
|
|
_skelImageWrapper.zeroBorder();
|
|
|
_array_helper2.default.init(_labelImageWrapper.data, 0);
|
|
|
rasterizer = _rasterizer2.default.create(_skelImageWrapper, _labelImageWrapper);
|
|
|
rasterResult = rasterizer.rasterize(0);
|
|
|
|
|
|
if (false) {
|
|
|
_labelImageWrapper.overlay(_canvasContainer.dom.binary, Math.floor(360 / rasterResult.count), { x: x, y: y });
|
|
|
}
|
|
|
|
|
|
// calculate moments from the skeletonized patch
|
|
|
moments = _labelImageWrapper.moments(rasterResult.count);
|
|
|
|
|
|
// extract eligible patches
|
|
|
patchesFound = patchesFound.concat(describePatch(moments, [i, j], x, y));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (false) {
|
|
|
for (i = 0; i < patchesFound.length; i++) {
|
|
|
patch = patchesFound[i];
|
|
|
_image_debug2.default.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "#99ff00", lineWidth: 2 });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return patchesFound;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Finds those connected areas which contain at least 6 patches
|
|
|
* and returns them ordered DESC by the number of contained patches
|
|
|
* @param {Number} maxLabel
|
|
|
*/
|
|
|
function findBiggestConnectedAreas(maxLabel) {
|
|
|
var i,
|
|
|
sum,
|
|
|
labelHist = [],
|
|
|
topLabels = [];
|
|
|
|
|
|
for (i = 0; i < maxLabel; i++) {
|
|
|
labelHist.push(0);
|
|
|
}
|
|
|
sum = _patchLabelGrid.data.length;
|
|
|
while (sum--) {
|
|
|
if (_patchLabelGrid.data[sum] > 0) {
|
|
|
labelHist[_patchLabelGrid.data[sum] - 1]++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
labelHist = labelHist.map(function (val, idx) {
|
|
|
return {
|
|
|
val: val,
|
|
|
label: idx + 1
|
|
|
};
|
|
|
});
|
|
|
|
|
|
labelHist.sort(function (a, b) {
|
|
|
return b.val - a.val;
|
|
|
});
|
|
|
|
|
|
// extract top areas with at least 6 patches present
|
|
|
topLabels = labelHist.filter(function (el) {
|
|
|
return el.val >= 5;
|
|
|
});
|
|
|
|
|
|
return topLabels;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
*
|
|
|
*/
|
|
|
function findBoxes(topLabels, maxLabel) {
|
|
|
var i,
|
|
|
j,
|
|
|
sum,
|
|
|
patches = [],
|
|
|
patch,
|
|
|
box,
|
|
|
boxes = [],
|
|
|
hsv = [0, 1, 1],
|
|
|
rgb = [0, 0, 0];
|
|
|
|
|
|
for (i = 0; i < topLabels.length; i++) {
|
|
|
sum = _patchLabelGrid.data.length;
|
|
|
patches.length = 0;
|
|
|
while (sum--) {
|
|
|
if (_patchLabelGrid.data[sum] === topLabels[i].label) {
|
|
|
patch = _imageToPatchGrid.data[sum];
|
|
|
patches.push(patch);
|
|
|
}
|
|
|
}
|
|
|
box = boxFromPatches(patches);
|
|
|
if (box) {
|
|
|
boxes.push(box);
|
|
|
|
|
|
// draw patch-labels if requested
|
|
|
if (false) {
|
|
|
for (j = 0; j < patches.length; j++) {
|
|
|
patch = patches[j];
|
|
|
hsv[0] = topLabels[i].label / (maxLabel + 1) * 360;
|
|
|
(0, _cv_utils.hsv2rgb)(hsv, rgb);
|
|
|
_image_debug2.default.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "rgb(" + rgb.join(",") + ")", lineWidth: 2 });
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return boxes;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Find similar moments (via cluster)
|
|
|
* @param {Object} moments
|
|
|
*/
|
|
|
function similarMoments(moments) {
|
|
|
var clusters = (0, _cv_utils.cluster)(moments, 0.90);
|
|
|
var topCluster = (0, _cv_utils.topGeneric)(clusters, 1, function (e) {
|
|
|
return e.getPoints().length;
|
|
|
});
|
|
|
var points = [],
|
|
|
result = [];
|
|
|
if (topCluster.length === 1) {
|
|
|
points = topCluster[0].item.getPoints();
|
|
|
for (var i = 0; i < points.length; i++) {
|
|
|
result.push(points[i].point);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
function skeletonize(x, y) {
|
|
|
_binaryImageWrapper.subImageAsCopy(_subImageWrapper, (0, _cv_utils.imageRef)(x, y));
|
|
|
_skeletonizer.skeletonize();
|
|
|
|
|
|
// Show skeleton if requested
|
|
|
if (false) {
|
|
|
_skelImageWrapper.overlay(_canvasContainer.dom.binary, 360, (0, _cv_utils.imageRef)(x, y));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Extracts and describes those patches which seem to contain a barcode pattern
|
|
|
* @param {Array} moments
|
|
|
* @param {Object} patchPos,
|
|
|
* @param {Number} x
|
|
|
* @param {Number} y
|
|
|
* @returns {Array} list of patches
|
|
|
*/
|
|
|
function describePatch(moments, patchPos, x, y) {
|
|
|
var k,
|
|
|
avg,
|
|
|
eligibleMoments = [],
|
|
|
matchingMoments,
|
|
|
patch,
|
|
|
patchesFound = [],
|
|
|
minComponentWeight = Math.ceil(_patchSize.x / 3);
|
|
|
|
|
|
if (moments.length >= 2) {
|
|
|
// only collect moments which's area covers at least minComponentWeight pixels.
|
|
|
for (k = 0; k < moments.length; k++) {
|
|
|
if (moments[k].m00 > minComponentWeight) {
|
|
|
eligibleMoments.push(moments[k]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// if at least 2 moments are found which have at least minComponentWeights covered
|
|
|
if (eligibleMoments.length >= 2) {
|
|
|
matchingMoments = similarMoments(eligibleMoments);
|
|
|
avg = 0;
|
|
|
// determine the similarity of the moments
|
|
|
for (k = 0; k < matchingMoments.length; k++) {
|
|
|
avg += matchingMoments[k].rad;
|
|
|
}
|
|
|
|
|
|
// Only two of the moments are allowed not to fit into the equation
|
|
|
// add the patch to the set
|
|
|
if (matchingMoments.length > 1 && matchingMoments.length >= eligibleMoments.length / 4 * 3 && matchingMoments.length > moments.length / 4) {
|
|
|
avg /= matchingMoments.length;
|
|
|
patch = {
|
|
|
index: patchPos[1] * _numPatches.x + patchPos[0],
|
|
|
pos: {
|
|
|
x: x,
|
|
|
y: y
|
|
|
},
|
|
|
box: [vec2.clone([x, y]), vec2.clone([x + _subImageWrapper.size.x, y]), vec2.clone([x + _subImageWrapper.size.x, y + _subImageWrapper.size.y]), vec2.clone([x, y + _subImageWrapper.size.y])],
|
|
|
moments: matchingMoments,
|
|
|
rad: avg,
|
|
|
vec: vec2.clone([Math.cos(avg), Math.sin(avg)])
|
|
|
};
|
|
|
patchesFound.push(patch);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return patchesFound;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* finds patches which are connected and share the same orientation
|
|
|
* @param {Object} patchesFound
|
|
|
*/
|
|
|
function rasterizeAngularSimilarity(patchesFound) {
|
|
|
var label = 0,
|
|
|
threshold = 0.95,
|
|
|
currIdx = 0,
|
|
|
j,
|
|
|
patch,
|
|
|
hsv = [0, 1, 1],
|
|
|
rgb = [0, 0, 0];
|
|
|
|
|
|
function notYetProcessed() {
|
|
|
var i;
|
|
|
for (i = 0; i < _patchLabelGrid.data.length; i++) {
|
|
|
if (_patchLabelGrid.data[i] === 0 && _patchGrid.data[i] === 1) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return _patchLabelGrid.length;
|
|
|
}
|
|
|
|
|
|
function trace(currentIdx) {
|
|
|
var x,
|
|
|
y,
|
|
|
currentPatch,
|
|
|
idx,
|
|
|
dir,
|
|
|
current = {
|
|
|
x: currentIdx % _patchLabelGrid.size.x,
|
|
|
y: currentIdx / _patchLabelGrid.size.x | 0
|
|
|
},
|
|
|
similarity;
|
|
|
|
|
|
if (currentIdx < _patchLabelGrid.data.length) {
|
|
|
currentPatch = _imageToPatchGrid.data[currentIdx];
|
|
|
// assign label
|
|
|
_patchLabelGrid.data[currentIdx] = label;
|
|
|
for (dir = 0; dir < _tracer2.default.searchDirections.length; dir++) {
|
|
|
y = current.y + _tracer2.default.searchDirections[dir][0];
|
|
|
x = current.x + _tracer2.default.searchDirections[dir][1];
|
|
|
idx = y * _patchLabelGrid.size.x + x;
|
|
|
|
|
|
// continue if patch empty
|
|
|
if (_patchGrid.data[idx] === 0) {
|
|
|
_patchLabelGrid.data[idx] = Number.MAX_VALUE;
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (_patchLabelGrid.data[idx] === 0) {
|
|
|
similarity = Math.abs(vec2.dot(_imageToPatchGrid.data[idx].vec, currentPatch.vec));
|
|
|
if (similarity > threshold) {
|
|
|
trace(idx);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// prepare for finding the right patches
|
|
|
_array_helper2.default.init(_patchGrid.data, 0);
|
|
|
_array_helper2.default.init(_patchLabelGrid.data, 0);
|
|
|
_array_helper2.default.init(_imageToPatchGrid.data, null);
|
|
|
|
|
|
for (j = 0; j < patchesFound.length; j++) {
|
|
|
patch = patchesFound[j];
|
|
|
_imageToPatchGrid.data[patch.index] = patch;
|
|
|
_patchGrid.data[patch.index] = 1;
|
|
|
}
|
|
|
|
|
|
// rasterize the patches found to determine area
|
|
|
_patchGrid.zeroBorder();
|
|
|
|
|
|
while ((currIdx = notYetProcessed()) < _patchLabelGrid.data.length) {
|
|
|
label++;
|
|
|
trace(currIdx);
|
|
|
}
|
|
|
|
|
|
// draw patch-labels if requested
|
|
|
if (false) {
|
|
|
for (j = 0; j < _patchLabelGrid.data.length; j++) {
|
|
|
if (_patchLabelGrid.data[j] > 0 && _patchLabelGrid.data[j] <= label) {
|
|
|
patch = _imageToPatchGrid.data[j];
|
|
|
hsv[0] = _patchLabelGrid.data[j] / (label + 1) * 360;
|
|
|
(0, _cv_utils.hsv2rgb)(hsv, rgb);
|
|
|
_image_debug2.default.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "rgb(" + rgb.join(",") + ")", lineWidth: 2 });
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return label;
|
|
|
}
|
|
|
|
|
|
exports.default = {
|
|
|
init: function init(inputImageWrapper, config) {
|
|
|
_config = config;
|
|
|
_inputImageWrapper = inputImageWrapper;
|
|
|
|
|
|
initBuffers();
|
|
|
initCanvas();
|
|
|
},
|
|
|
|
|
|
locate: function locate() {
|
|
|
var patchesFound, topLabels, boxes;
|
|
|
|
|
|
if (_config.halfSample) {
|
|
|
(0, _cv_utils.halfSample)(_inputImageWrapper, _currentImageWrapper);
|
|
|
}
|
|
|
|
|
|
binarizeImage();
|
|
|
patchesFound = findPatches();
|
|
|
// return unless 5% or more patches are found
|
|
|
if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
// rasterrize area by comparing angular similarity;
|
|
|
var maxLabel = rasterizeAngularSimilarity(patchesFound);
|
|
|
if (maxLabel < 1) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
// search for area with the most patches (biggest connected area)
|
|
|
topLabels = findBiggestConnectedAreas(maxLabel);
|
|
|
if (topLabels.length === 0) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
boxes = findBoxes(topLabels, maxLabel);
|
|
|
return boxes;
|
|
|
},
|
|
|
|
|
|
checkImageConstraints: function checkImageConstraints(inputStream, config) {
|
|
|
var patchSize,
|
|
|
width = inputStream.getWidth(),
|
|
|
height = inputStream.getHeight(),
|
|
|
halfSample = config.halfSample ? 0.5 : 1,
|
|
|
size,
|
|
|
area;
|
|
|
|
|
|
// calculate width and height based on area
|
|
|
if (inputStream.getConfig().area) {
|
|
|
area = (0, _cv_utils.computeImageArea)(width, height, inputStream.getConfig().area);
|
|
|
inputStream.setTopRight({ x: area.sx, y: area.sy });
|
|
|
inputStream.setCanvasSize({ x: width, y: height });
|
|
|
width = area.sw;
|
|
|
height = area.sh;
|
|
|
}
|
|
|
|
|
|
size = {
|
|
|
x: Math.floor(width * halfSample),
|
|
|
y: Math.floor(height * halfSample)
|
|
|
};
|
|
|
|
|
|
patchSize = (0, _cv_utils.calculatePatchSize)(config.patchSize, size);
|
|
|
if (false) {
|
|
|
console.log("Patch-Size: " + JSON.stringify(patchSize));
|
|
|
}
|
|
|
|
|
|
inputStream.setWidth(Math.floor(Math.floor(size.x / patchSize.x) * (1 / halfSample) * patchSize.x));
|
|
|
inputStream.setHeight(Math.floor(Math.floor(size.y / patchSize.y) * (1 / halfSample) * patchSize.y));
|
|
|
|
|
|
if (inputStream.getWidth() % patchSize.x === 0 && inputStream.getHeight() % patchSize.y === 0) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
throw new Error("Image dimensions do not comply with the current settings: Width (" + width + " )and height (" + height + ") must a multiple of " + patchSize.x);
|
|
|
}
|
|
|
};
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(70)))
|
|
|
|
|
|
/***/ }),
|
|
|
/* 86 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _tracer = __webpack_require__(42);
|
|
|
|
|
|
var _tracer2 = _interopRequireDefault(_tracer);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
/**
|
|
|
* http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
|
|
|
*/
|
|
|
var Rasterizer = {
|
|
|
createContour2D: function createContour2D() {
|
|
|
return {
|
|
|
dir: null,
|
|
|
index: null,
|
|
|
firstVertex: null,
|
|
|
insideContours: null,
|
|
|
nextpeer: null,
|
|
|
prevpeer: null
|
|
|
};
|
|
|
},
|
|
|
CONTOUR_DIR: {
|
|
|
CW_DIR: 0,
|
|
|
CCW_DIR: 1,
|
|
|
UNKNOWN_DIR: 2
|
|
|
},
|
|
|
DIR: {
|
|
|
OUTSIDE_EDGE: -32767,
|
|
|
INSIDE_EDGE: -32766
|
|
|
},
|
|
|
create: function create(imageWrapper, labelWrapper) {
|
|
|
var imageData = imageWrapper.data,
|
|
|
labelData = labelWrapper.data,
|
|
|
width = imageWrapper.size.x,
|
|
|
height = imageWrapper.size.y,
|
|
|
tracer = _tracer2.default.create(imageWrapper, labelWrapper);
|
|
|
|
|
|
return {
|
|
|
rasterize: function rasterize(depthlabel) {
|
|
|
var color,
|
|
|
bc,
|
|
|
lc,
|
|
|
labelindex,
|
|
|
cx,
|
|
|
cy,
|
|
|
colorMap = [],
|
|
|
vertex,
|
|
|
p,
|
|
|
cc,
|
|
|
sc,
|
|
|
pos,
|
|
|
connectedCount = 0,
|
|
|
i;
|
|
|
|
|
|
for (i = 0; i < 400; i++) {
|
|
|
colorMap[i] = 0;
|
|
|
}
|
|
|
|
|
|
colorMap[0] = imageData[0];
|
|
|
cc = null;
|
|
|
for (cy = 1; cy < height - 1; cy++) {
|
|
|
labelindex = 0;
|
|
|
bc = colorMap[0];
|
|
|
for (cx = 1; cx < width - 1; cx++) {
|
|
|
pos = cy * width + cx;
|
|
|
if (labelData[pos] === 0) {
|
|
|
color = imageData[pos];
|
|
|
if (color !== bc) {
|
|
|
if (labelindex === 0) {
|
|
|
lc = connectedCount + 1;
|
|
|
colorMap[lc] = color;
|
|
|
bc = color;
|
|
|
vertex = tracer.contourTracing(cy, cx, lc, color, Rasterizer.DIR.OUTSIDE_EDGE);
|
|
|
if (vertex !== null) {
|
|
|
connectedCount++;
|
|
|
labelindex = lc;
|
|
|
p = Rasterizer.createContour2D();
|
|
|
p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;
|
|
|
p.index = labelindex;
|
|
|
p.firstVertex = vertex;
|
|
|
p.nextpeer = cc;
|
|
|
p.insideContours = null;
|
|
|
if (cc !== null) {
|
|
|
cc.prevpeer = p;
|
|
|
}
|
|
|
cc = p;
|
|
|
}
|
|
|
} else {
|
|
|
vertex = tracer.contourTracing(cy, cx, Rasterizer.DIR.INSIDE_EDGE, color, labelindex);
|
|
|
if (vertex !== null) {
|
|
|
p = Rasterizer.createContour2D();
|
|
|
p.firstVertex = vertex;
|
|
|
p.insideContours = null;
|
|
|
if (depthlabel === 0) {
|
|
|
p.dir = Rasterizer.CONTOUR_DIR.CCW_DIR;
|
|
|
} else {
|
|
|
p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;
|
|
|
}
|
|
|
p.index = depthlabel;
|
|
|
sc = cc;
|
|
|
while (sc !== null && sc.index !== labelindex) {
|
|
|
sc = sc.nextpeer;
|
|
|
}
|
|
|
if (sc !== null) {
|
|
|
p.nextpeer = sc.insideContours;
|
|
|
if (sc.insideContours !== null) {
|
|
|
sc.insideContours.prevpeer = p;
|
|
|
}
|
|
|
sc.insideContours = p;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
labelData[pos] = labelindex;
|
|
|
}
|
|
|
} else if (labelData[pos] === Rasterizer.DIR.OUTSIDE_EDGE || labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {
|
|
|
labelindex = 0;
|
|
|
if (labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {
|
|
|
bc = imageData[pos];
|
|
|
} else {
|
|
|
bc = colorMap[0];
|
|
|
}
|
|
|
} else {
|
|
|
labelindex = labelData[pos];
|
|
|
bc = colorMap[labelindex];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
sc = cc;
|
|
|
while (sc !== null) {
|
|
|
sc.index = depthlabel;
|
|
|
sc = sc.nextpeer;
|
|
|
}
|
|
|
return {
|
|
|
cc: cc,
|
|
|
count: connectedCount
|
|
|
};
|
|
|
},
|
|
|
debug: {
|
|
|
drawContour: function drawContour(canvas, firstContour) {
|
|
|
var ctx = canvas.getContext("2d"),
|
|
|
pq = firstContour,
|
|
|
iq,
|
|
|
q,
|
|
|
p;
|
|
|
|
|
|
ctx.strokeStyle = "red";
|
|
|
ctx.fillStyle = "red";
|
|
|
ctx.lineWidth = 1;
|
|
|
|
|
|
if (pq !== null) {
|
|
|
iq = pq.insideContours;
|
|
|
} else {
|
|
|
iq = null;
|
|
|
}
|
|
|
|
|
|
while (pq !== null) {
|
|
|
if (iq !== null) {
|
|
|
q = iq;
|
|
|
iq = iq.nextpeer;
|
|
|
} else {
|
|
|
q = pq;
|
|
|
pq = pq.nextpeer;
|
|
|
if (pq !== null) {
|
|
|
iq = pq.insideContours;
|
|
|
} else {
|
|
|
iq = null;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
switch (q.dir) {
|
|
|
case Rasterizer.CONTOUR_DIR.CW_DIR:
|
|
|
ctx.strokeStyle = "red";
|
|
|
break;
|
|
|
case Rasterizer.CONTOUR_DIR.CCW_DIR:
|
|
|
ctx.strokeStyle = "blue";
|
|
|
break;
|
|
|
case Rasterizer.CONTOUR_DIR.UNKNOWN_DIR:
|
|
|
ctx.strokeStyle = "green";
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
p = q.firstVertex;
|
|
|
ctx.beginPath();
|
|
|
ctx.moveTo(p.x, p.y);
|
|
|
do {
|
|
|
p = p.next;
|
|
|
ctx.lineTo(p.x, p.y);
|
|
|
} while (p !== q.firstVertex);
|
|
|
ctx.stroke();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = Rasterizer;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 87 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
/* @preserve ASM BEGIN */
|
|
|
/* eslint-disable eqeqeq*/
|
|
|
function Skeletonizer(stdlib, foreign, buffer) {
|
|
|
"use asm";
|
|
|
|
|
|
var images = new stdlib.Uint8Array(buffer),
|
|
|
size = foreign.size | 0,
|
|
|
imul = stdlib.Math.imul;
|
|
|
|
|
|
function erode(inImagePtr, outImagePtr) {
|
|
|
inImagePtr = inImagePtr | 0;
|
|
|
outImagePtr = outImagePtr | 0;
|
|
|
|
|
|
var v = 0,
|
|
|
u = 0,
|
|
|
sum = 0,
|
|
|
yStart1 = 0,
|
|
|
yStart2 = 0,
|
|
|
xStart1 = 0,
|
|
|
xStart2 = 0,
|
|
|
offset = 0;
|
|
|
|
|
|
for (v = 1; (v | 0) < (size - 1 | 0); v = v + 1 | 0) {
|
|
|
offset = offset + size | 0;
|
|
|
for (u = 1; (u | 0) < (size - 1 | 0); u = u + 1 | 0) {
|
|
|
yStart1 = offset - size | 0;
|
|
|
yStart2 = offset + size | 0;
|
|
|
xStart1 = u - 1 | 0;
|
|
|
xStart2 = u + 1 | 0;
|
|
|
sum = (images[inImagePtr + yStart1 + xStart1 | 0] | 0) + (images[inImagePtr + yStart1 + xStart2 | 0] | 0) + (images[inImagePtr + offset + u | 0] | 0) + (images[inImagePtr + yStart2 + xStart1 | 0] | 0) + (images[inImagePtr + yStart2 + xStart2 | 0] | 0) | 0;
|
|
|
if ((sum | 0) == (5 | 0)) {
|
|
|
images[outImagePtr + offset + u | 0] = 1;
|
|
|
} else {
|
|
|
images[outImagePtr + offset + u | 0] = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
function subtract(aImagePtr, bImagePtr, outImagePtr) {
|
|
|
aImagePtr = aImagePtr | 0;
|
|
|
bImagePtr = bImagePtr | 0;
|
|
|
outImagePtr = outImagePtr | 0;
|
|
|
|
|
|
var length = 0;
|
|
|
|
|
|
length = imul(size, size) | 0;
|
|
|
|
|
|
while ((length | 0) > 0) {
|
|
|
length = length - 1 | 0;
|
|
|
images[outImagePtr + length | 0] = (images[aImagePtr + length | 0] | 0) - (images[bImagePtr + length | 0] | 0) | 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {
|
|
|
aImagePtr = aImagePtr | 0;
|
|
|
bImagePtr = bImagePtr | 0;
|
|
|
outImagePtr = outImagePtr | 0;
|
|
|
|
|
|
var length = 0;
|
|
|
|
|
|
length = imul(size, size) | 0;
|
|
|
|
|
|
while ((length | 0) > 0) {
|
|
|
length = length - 1 | 0;
|
|
|
images[outImagePtr + length | 0] = images[aImagePtr + length | 0] | 0 | (images[bImagePtr + length | 0] | 0) | 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function countNonZero(imagePtr) {
|
|
|
imagePtr = imagePtr | 0;
|
|
|
|
|
|
var sum = 0,
|
|
|
length = 0;
|
|
|
|
|
|
length = imul(size, size) | 0;
|
|
|
|
|
|
while ((length | 0) > 0) {
|
|
|
length = length - 1 | 0;
|
|
|
sum = (sum | 0) + (images[imagePtr + length | 0] | 0) | 0;
|
|
|
}
|
|
|
|
|
|
return sum | 0;
|
|
|
}
|
|
|
|
|
|
function init(imagePtr, value) {
|
|
|
imagePtr = imagePtr | 0;
|
|
|
value = value | 0;
|
|
|
|
|
|
var length = 0;
|
|
|
|
|
|
length = imul(size, size) | 0;
|
|
|
|
|
|
while ((length | 0) > 0) {
|
|
|
length = length - 1 | 0;
|
|
|
images[imagePtr + length | 0] = value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function dilate(inImagePtr, outImagePtr) {
|
|
|
inImagePtr = inImagePtr | 0;
|
|
|
outImagePtr = outImagePtr | 0;
|
|
|
|
|
|
var v = 0,
|
|
|
u = 0,
|
|
|
sum = 0,
|
|
|
yStart1 = 0,
|
|
|
yStart2 = 0,
|
|
|
xStart1 = 0,
|
|
|
xStart2 = 0,
|
|
|
offset = 0;
|
|
|
|
|
|
for (v = 1; (v | 0) < (size - 1 | 0); v = v + 1 | 0) {
|
|
|
offset = offset + size | 0;
|
|
|
for (u = 1; (u | 0) < (size - 1 | 0); u = u + 1 | 0) {
|
|
|
yStart1 = offset - size | 0;
|
|
|
yStart2 = offset + size | 0;
|
|
|
xStart1 = u - 1 | 0;
|
|
|
xStart2 = u + 1 | 0;
|
|
|
sum = (images[inImagePtr + yStart1 + xStart1 | 0] | 0) + (images[inImagePtr + yStart1 + xStart2 | 0] | 0) + (images[inImagePtr + offset + u | 0] | 0) + (images[inImagePtr + yStart2 + xStart1 | 0] | 0) + (images[inImagePtr + yStart2 + xStart2 | 0] | 0) | 0;
|
|
|
if ((sum | 0) > (0 | 0)) {
|
|
|
images[outImagePtr + offset + u | 0] = 1;
|
|
|
} else {
|
|
|
images[outImagePtr + offset + u | 0] = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
function memcpy(srcImagePtr, dstImagePtr) {
|
|
|
srcImagePtr = srcImagePtr | 0;
|
|
|
dstImagePtr = dstImagePtr | 0;
|
|
|
|
|
|
var length = 0;
|
|
|
|
|
|
length = imul(size, size) | 0;
|
|
|
|
|
|
while ((length | 0) > 0) {
|
|
|
length = length - 1 | 0;
|
|
|
images[dstImagePtr + length | 0] = images[srcImagePtr + length | 0] | 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function zeroBorder(imagePtr) {
|
|
|
imagePtr = imagePtr | 0;
|
|
|
|
|
|
var x = 0,
|
|
|
y = 0;
|
|
|
|
|
|
for (x = 0; (x | 0) < (size - 1 | 0); x = x + 1 | 0) {
|
|
|
images[imagePtr + x | 0] = 0;
|
|
|
images[imagePtr + y | 0] = 0;
|
|
|
y = y + size - 1 | 0;
|
|
|
images[imagePtr + y | 0] = 0;
|
|
|
y = y + 1 | 0;
|
|
|
}
|
|
|
for (x = 0; (x | 0) < (size | 0); x = x + 1 | 0) {
|
|
|
images[imagePtr + y | 0] = 0;
|
|
|
y = y + 1 | 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function skeletonize() {
|
|
|
var subImagePtr = 0,
|
|
|
erodedImagePtr = 0,
|
|
|
tempImagePtr = 0,
|
|
|
skelImagePtr = 0,
|
|
|
sum = 0,
|
|
|
done = 0;
|
|
|
|
|
|
erodedImagePtr = imul(size, size) | 0;
|
|
|
tempImagePtr = erodedImagePtr + erodedImagePtr | 0;
|
|
|
skelImagePtr = tempImagePtr + erodedImagePtr | 0;
|
|
|
|
|
|
// init skel-image
|
|
|
init(skelImagePtr, 0);
|
|
|
zeroBorder(subImagePtr);
|
|
|
|
|
|
do {
|
|
|
erode(subImagePtr, erodedImagePtr);
|
|
|
dilate(erodedImagePtr, tempImagePtr);
|
|
|
subtract(subImagePtr, tempImagePtr, tempImagePtr);
|
|
|
bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);
|
|
|
memcpy(erodedImagePtr, subImagePtr);
|
|
|
sum = countNonZero(subImagePtr) | 0;
|
|
|
done = (sum | 0) == 0 | 0;
|
|
|
} while (!done);
|
|
|
}
|
|
|
return {
|
|
|
skeletonize: skeletonize
|
|
|
};
|
|
|
}
|
|
|
/* @preserve ASM END */
|
|
|
exports.default = Skeletonizer;
|
|
|
/* eslint-enable eqeqeq*/
|
|
|
|
|
|
/***/ }),
|
|
|
/* 88 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _barcode_reader = __webpack_require__(10);
|
|
|
|
|
|
var _barcode_reader2 = _interopRequireDefault(_barcode_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function CodabarReader() {
|
|
|
_barcode_reader2.default.call(this);
|
|
|
this._counters = [];
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
ALPHABETH_STRING: { value: "0123456789-$:/.+ABCD" },
|
|
|
ALPHABET: { value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68] },
|
|
|
CHARACTER_ENCODINGS: { value: [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E] },
|
|
|
START_END: { value: [0x01A, 0x029, 0x00B, 0x00E] },
|
|
|
MIN_ENCODED_CHARS: { value: 4 },
|
|
|
MAX_ACCEPTABLE: { value: 2.0 },
|
|
|
PADDING: { value: 1.5 },
|
|
|
FORMAT: { value: "codabar", writeable: false }
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype = Object.create(_barcode_reader2.default.prototype, properties);
|
|
|
CodabarReader.prototype.constructor = CodabarReader;
|
|
|
|
|
|
CodabarReader.prototype._decode = function () {
|
|
|
var self = this,
|
|
|
result = [],
|
|
|
start,
|
|
|
decodedChar,
|
|
|
pattern,
|
|
|
nextStart,
|
|
|
end;
|
|
|
|
|
|
this._counters = self._fillCounters();
|
|
|
start = self._findStart();
|
|
|
if (!start) {
|
|
|
return null;
|
|
|
}
|
|
|
nextStart = start.startCounter;
|
|
|
|
|
|
do {
|
|
|
pattern = self._toPattern(nextStart);
|
|
|
if (pattern < 0) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedChar = self._patternToChar(pattern);
|
|
|
if (decodedChar < 0) {
|
|
|
return null;
|
|
|
}
|
|
|
result.push(decodedChar);
|
|
|
nextStart += 8;
|
|
|
if (result.length > 1 && self._isStartEnd(pattern)) {
|
|
|
break;
|
|
|
}
|
|
|
} while (nextStart < self._counters.length);
|
|
|
|
|
|
// verify end
|
|
|
if (result.length - 2 < self.MIN_ENCODED_CHARS || !self._isStartEnd(pattern)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
// verify end white space
|
|
|
if (!self._verifyWhitespace(start.startCounter, nextStart - 8)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (!self._validateResult(result, start.startCounter)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
nextStart = nextStart > self._counters.length ? self._counters.length : nextStart;
|
|
|
end = start.start + self._sumCounters(start.startCounter, nextStart - 8);
|
|
|
|
|
|
return {
|
|
|
code: result.join(""),
|
|
|
start: start.start,
|
|
|
end: end,
|
|
|
startInfo: start,
|
|
|
decodedCodes: result
|
|
|
};
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._verifyWhitespace = function (startCounter, endCounter) {
|
|
|
if (startCounter - 1 <= 0 || this._counters[startCounter - 1] >= this._calculatePatternLength(startCounter) / 2.0) {
|
|
|
if (endCounter + 8 >= this._counters.length || this._counters[endCounter + 7] >= this._calculatePatternLength(endCounter) / 2.0) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._calculatePatternLength = function (offset) {
|
|
|
var i,
|
|
|
sum = 0;
|
|
|
|
|
|
for (i = offset; i < offset + 7; i++) {
|
|
|
sum += this._counters[i];
|
|
|
}
|
|
|
|
|
|
return sum;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._thresholdResultPattern = function (result, startCounter) {
|
|
|
var self = this,
|
|
|
categorization = {
|
|
|
space: {
|
|
|
narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },
|
|
|
wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }
|
|
|
},
|
|
|
bar: {
|
|
|
narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },
|
|
|
wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }
|
|
|
}
|
|
|
},
|
|
|
kind,
|
|
|
cat,
|
|
|
i,
|
|
|
j,
|
|
|
pos = startCounter,
|
|
|
pattern;
|
|
|
|
|
|
for (i = 0; i < result.length; i++) {
|
|
|
pattern = self._charToPattern(result[i]);
|
|
|
for (j = 6; j >= 0; j--) {
|
|
|
kind = (j & 1) === 2 ? categorization.bar : categorization.space;
|
|
|
cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;
|
|
|
cat.size += self._counters[pos + j];
|
|
|
cat.counts++;
|
|
|
pattern >>= 1;
|
|
|
}
|
|
|
pos += 8;
|
|
|
}
|
|
|
|
|
|
["space", "bar"].forEach(function (key) {
|
|
|
var newkind = categorization[key];
|
|
|
newkind.wide.min = Math.floor((newkind.narrow.size / newkind.narrow.counts + newkind.wide.size / newkind.wide.counts) / 2);
|
|
|
newkind.narrow.max = Math.ceil(newkind.wide.min);
|
|
|
newkind.wide.max = Math.ceil((newkind.wide.size * self.MAX_ACCEPTABLE + self.PADDING) / newkind.wide.counts);
|
|
|
});
|
|
|
|
|
|
return categorization;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._charToPattern = function (char) {
|
|
|
var self = this,
|
|
|
charCode = char.charCodeAt(0),
|
|
|
i;
|
|
|
|
|
|
for (i = 0; i < self.ALPHABET.length; i++) {
|
|
|
if (self.ALPHABET[i] === charCode) {
|
|
|
return self.CHARACTER_ENCODINGS[i];
|
|
|
}
|
|
|
}
|
|
|
return 0x0;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._validateResult = function (result, startCounter) {
|
|
|
var self = this,
|
|
|
thresholds = self._thresholdResultPattern(result, startCounter),
|
|
|
i,
|
|
|
j,
|
|
|
kind,
|
|
|
cat,
|
|
|
size,
|
|
|
pos = startCounter,
|
|
|
pattern;
|
|
|
|
|
|
for (i = 0; i < result.length; i++) {
|
|
|
pattern = self._charToPattern(result[i]);
|
|
|
for (j = 6; j >= 0; j--) {
|
|
|
kind = (j & 1) === 0 ? thresholds.bar : thresholds.space;
|
|
|
cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;
|
|
|
size = self._counters[pos + j];
|
|
|
if (size < cat.min || size > cat.max) {
|
|
|
return false;
|
|
|
}
|
|
|
pattern >>= 1;
|
|
|
}
|
|
|
pos += 8;
|
|
|
}
|
|
|
return true;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._patternToChar = function (pattern) {
|
|
|
var i,
|
|
|
self = this;
|
|
|
|
|
|
for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {
|
|
|
if (self.CHARACTER_ENCODINGS[i] === pattern) {
|
|
|
return String.fromCharCode(self.ALPHABET[i]);
|
|
|
}
|
|
|
}
|
|
|
return -1;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._computeAlternatingThreshold = function (offset, end) {
|
|
|
var i,
|
|
|
min = Number.MAX_VALUE,
|
|
|
max = 0,
|
|
|
counter;
|
|
|
|
|
|
for (i = offset; i < end; i += 2) {
|
|
|
counter = this._counters[i];
|
|
|
if (counter > max) {
|
|
|
max = counter;
|
|
|
}
|
|
|
if (counter < min) {
|
|
|
min = counter;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return (min + max) / 2.0 | 0;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._toPattern = function (offset) {
|
|
|
var numCounters = 7,
|
|
|
end = offset + numCounters,
|
|
|
barThreshold,
|
|
|
spaceThreshold,
|
|
|
bitmask = 1 << numCounters - 1,
|
|
|
pattern = 0,
|
|
|
i,
|
|
|
threshold;
|
|
|
|
|
|
if (end > this._counters.length) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
barThreshold = this._computeAlternatingThreshold(offset, end);
|
|
|
spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);
|
|
|
|
|
|
for (i = 0; i < numCounters; i++) {
|
|
|
threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;
|
|
|
if (this._counters[offset + i] > threshold) {
|
|
|
pattern |= bitmask;
|
|
|
}
|
|
|
bitmask >>= 1;
|
|
|
}
|
|
|
|
|
|
return pattern;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._isStartEnd = function (pattern) {
|
|
|
var i;
|
|
|
|
|
|
for (i = 0; i < this.START_END.length; i++) {
|
|
|
if (this.START_END[i] === pattern) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._sumCounters = function (start, end) {
|
|
|
var i,
|
|
|
sum = 0;
|
|
|
|
|
|
for (i = start; i < end; i++) {
|
|
|
sum += this._counters[i];
|
|
|
}
|
|
|
return sum;
|
|
|
};
|
|
|
|
|
|
CodabarReader.prototype._findStart = function () {
|
|
|
var self = this,
|
|
|
i,
|
|
|
pattern,
|
|
|
start = self._nextUnset(self._row),
|
|
|
end;
|
|
|
|
|
|
for (i = 1; i < this._counters.length; i++) {
|
|
|
pattern = self._toPattern(i);
|
|
|
if (pattern !== -1 && self._isStartEnd(pattern)) {
|
|
|
// TODO: Look for whitespace ahead
|
|
|
start += self._sumCounters(0, i);
|
|
|
end = start + self._sumCounters(i, i + 8);
|
|
|
return {
|
|
|
start: start,
|
|
|
end: end,
|
|
|
startCounter: i,
|
|
|
endCounter: i + 8
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = CodabarReader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 89 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _barcode_reader = __webpack_require__(10);
|
|
|
|
|
|
var _barcode_reader2 = _interopRequireDefault(_barcode_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function Code128Reader() {
|
|
|
_barcode_reader2.default.call(this);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
CODE_SHIFT: { value: 98 },
|
|
|
CODE_C: { value: 99 },
|
|
|
CODE_B: { value: 100 },
|
|
|
CODE_A: { value: 101 },
|
|
|
START_CODE_A: { value: 103 },
|
|
|
START_CODE_B: { value: 104 },
|
|
|
START_CODE_C: { value: 105 },
|
|
|
STOP_CODE: { value: 106 },
|
|
|
CODE_PATTERN: { value: [[2, 1, 2, 2, 2, 2], [2, 2, 2, 1, 2, 2], [2, 2, 2, 2, 2, 1], [1, 2, 1, 2, 2, 3], [1, 2, 1, 3, 2, 2], [1, 3, 1, 2, 2, 2], [1, 2, 2, 2, 1, 3], [1, 2, 2, 3, 1, 2], [1, 3, 2, 2, 1, 2], [2, 2, 1, 2, 1, 3], [2, 2, 1, 3, 1, 2], [2, 3, 1, 2, 1, 2], [1, 1, 2, 2, 3, 2], [1, 2, 2, 1, 3, 2], [1, 2, 2, 2, 3, 1], [1, 1, 3, 2, 2, 2], [1, 2, 3, 1, 2, 2], [1, 2, 3, 2, 2, 1], [2, 2, 3, 2, 1, 1], [2, 2, 1, 1, 3, 2], [2, 2, 1, 2, 3, 1], [2, 1, 3, 2, 1, 2], [2, 2, 3, 1, 1, 2], [3, 1, 2, 1, 3, 1], [3, 1, 1, 2, 2, 2], [3, 2, 1, 1, 2, 2], [3, 2, 1, 2, 2, 1], [3, 1, 2, 2, 1, 2], [3, 2, 2, 1, 1, 2], [3, 2, 2, 2, 1, 1], [2, 1, 2, 1, 2, 3], [2, 1, 2, 3, 2, 1], [2, 3, 2, 1, 2, 1], [1, 1, 1, 3, 2, 3], [1, 3, 1, 1, 2, 3], [1, 3, 1, 3, 2, 1], [1, 1, 2, 3, 1, 3], [1, 3, 2, 1, 1, 3], [1, 3, 2, 3, 1, 1], [2, 1, 1, 3, 1, 3], [2, 3, 1, 1, 1, 3], [2, 3, 1, 3, 1, 1], [1, 1, 2, 1, 3, 3], [1, 1, 2, 3, 3, 1], [1, 3, 2, 1, 3, 1], [1, 1, 3, 1, 2, 3], [1, 1, 3, 3, 2, 1], [1, 3, 3, 1, 2, 1], [3, 1, 3, 1, 2, 1], [2, 1, 1, 3, 3, 1], [2, 3, 1, 1, 3, 1], [2, 1, 3, 1, 1, 3], [2, 1, 3, 3, 1, 1], [2, 1, 3, 1, 3, 1], [3, 1, 1, 1, 2, 3], [3, 1, 1, 3, 2, 1], [3, 3, 1, 1, 2, 1], [3, 1, 2, 1, 1, 3], [3, 1, 2, 3, 1, 1], [3, 3, 2, 1, 1, 1], [3, 1, 4, 1, 1, 1], [2, 2, 1, 4, 1, 1], [4, 3, 1, 1, 1, 1], [1, 1, 1, 2, 2, 4], [1, 1, 1, 4, 2, 2], [1, 2, 1, 1, 2, 4], [1, 2, 1, 4, 2, 1], [1, 4, 1, 1, 2, 2], [1, 4, 1, 2, 2, 1], [1, 1, 2, 2, 1, 4], [1, 1, 2, 4, 1, 2], [1, 2, 2, 1, 1, 4], [1, 2, 2, 4, 1, 1], [1, 4, 2, 1, 1, 2], [1, 4, 2, 2, 1, 1], [2, 4, 1, 2, 1, 1], [2, 2, 1, 1, 1, 4], [4, 1, 3, 1, 1, 1], [2, 4, 1, 1, 1, 2], [1, 3, 4, 1, 1, 1], [1, 1, 1, 2, 4, 2], [1, 2, 1, 1, 4, 2], [1, 2, 1, 2, 4, 1], [1, 1, 4, 2, 1, 2], [1, 2, 4, 1, 1, 2], [1, 2, 4, 2, 1, 1], [4, 1, 1, 2, 1, 2], [4, 2, 1, 1, 1, 2], [4, 2, 1, 2, 1, 1], [2, 1, 2, 1, 4, 1], [2, 1, 4, 1, 2, 1], [4, 1, 2, 1, 2, 1], [1, 1, 1, 1, 4, 3], [1, 1, 1, 3, 4, 1], [1, 3, 1, 1, 4, 1], [1, 1, 4, 1, 1, 3], [1, 1, 4, 3, 1, 1], [4, 1, 1, 1, 1, 3], [4, 1, 1, 3, 1, 1], [1, 1, 3, 1, 4, 1], [1, 1, 4, 1, 3, 1], [3, 1, 1, 1, 4, 1], [4, 1, 1, 1, 3, 1], [2, 1, 1, 4, 1, 2], [2, 1, 1, 2, 1, 4], [2, 1, 1, 2, 3, 2], [2, 3, 3, 1, 1, 1, 2]] },
|
|
|
SINGLE_CODE_ERROR: { value: 0.64 },
|
|
|
AVG_CODE_ERROR: { value: 0.30 },
|
|
|
FORMAT: { value: "code_128", writeable: false },
|
|
|
MODULE_INDICES: { value: { bar: [0, 2, 4], space: [1, 3, 5] } }
|
|
|
};
|
|
|
|
|
|
Code128Reader.prototype = Object.create(_barcode_reader2.default.prototype, properties);
|
|
|
Code128Reader.prototype.constructor = Code128Reader;
|
|
|
|
|
|
Code128Reader.prototype._decodeCode = function (start, correction) {
|
|
|
var counter = [0, 0, 0, 0, 0, 0],
|
|
|
i,
|
|
|
self = this,
|
|
|
offset = start,
|
|
|
isWhite = !self._row[offset],
|
|
|
counterPos = 0,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: start,
|
|
|
end: start,
|
|
|
correction: {
|
|
|
bar: 1,
|
|
|
space: 1
|
|
|
}
|
|
|
},
|
|
|
code,
|
|
|
error;
|
|
|
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
if (correction) {
|
|
|
self._correct(counter, correction);
|
|
|
}
|
|
|
for (code = 0; code < self.CODE_PATTERN.length; code++) {
|
|
|
error = self._matchPattern(counter, self.CODE_PATTERN[code]);
|
|
|
if (error < bestMatch.error) {
|
|
|
bestMatch.code = code;
|
|
|
bestMatch.error = error;
|
|
|
}
|
|
|
}
|
|
|
bestMatch.end = i;
|
|
|
if (bestMatch.code === -1 || bestMatch.error > self.AVG_CODE_ERROR) {
|
|
|
return null;
|
|
|
}
|
|
|
if (self.CODE_PATTERN[bestMatch.code]) {
|
|
|
bestMatch.correction.bar = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.bar);
|
|
|
bestMatch.correction.space = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.space);
|
|
|
}
|
|
|
return bestMatch;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
Code128Reader.prototype._correct = function (counter, correction) {
|
|
|
this._correctBars(counter, correction.bar, this.MODULE_INDICES.bar);
|
|
|
this._correctBars(counter, correction.space, this.MODULE_INDICES.space);
|
|
|
};
|
|
|
|
|
|
Code128Reader.prototype._findStart = function () {
|
|
|
var counter = [0, 0, 0, 0, 0, 0],
|
|
|
i,
|
|
|
self = this,
|
|
|
offset = self._nextSet(self._row),
|
|
|
isWhite = false,
|
|
|
counterPos = 0,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: 0,
|
|
|
end: 0,
|
|
|
correction: {
|
|
|
bar: 1,
|
|
|
space: 1
|
|
|
}
|
|
|
},
|
|
|
code,
|
|
|
error,
|
|
|
j,
|
|
|
sum;
|
|
|
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
sum = 0;
|
|
|
for (j = 0; j < counter.length; j++) {
|
|
|
sum += counter[j];
|
|
|
}
|
|
|
for (code = self.START_CODE_A; code <= self.START_CODE_C; code++) {
|
|
|
error = self._matchPattern(counter, self.CODE_PATTERN[code]);
|
|
|
if (error < bestMatch.error) {
|
|
|
bestMatch.code = code;
|
|
|
bestMatch.error = error;
|
|
|
}
|
|
|
}
|
|
|
if (bestMatch.error < self.AVG_CODE_ERROR) {
|
|
|
bestMatch.start = i - sum;
|
|
|
bestMatch.end = i;
|
|
|
bestMatch.correction.bar = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.bar);
|
|
|
bestMatch.correction.space = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.space);
|
|
|
return bestMatch;
|
|
|
}
|
|
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
counter[j] = counter[j + 2];
|
|
|
}
|
|
|
counter[4] = 0;
|
|
|
counter[5] = 0;
|
|
|
counterPos--;
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
Code128Reader.prototype._decode = function () {
|
|
|
var self = this,
|
|
|
startInfo = self._findStart(),
|
|
|
code = null,
|
|
|
done = false,
|
|
|
result = [],
|
|
|
multiplier = 0,
|
|
|
checksum = 0,
|
|
|
codeset,
|
|
|
rawResult = [],
|
|
|
decodedCodes = [],
|
|
|
shiftNext = false,
|
|
|
unshift,
|
|
|
removeLastCharacter = true;
|
|
|
|
|
|
if (startInfo === null) {
|
|
|
return null;
|
|
|
}
|
|
|
code = {
|
|
|
code: startInfo.code,
|
|
|
start: startInfo.start,
|
|
|
end: startInfo.end,
|
|
|
correction: {
|
|
|
bar: startInfo.correction.bar,
|
|
|
space: startInfo.correction.space
|
|
|
}
|
|
|
};
|
|
|
decodedCodes.push(code);
|
|
|
checksum = code.code;
|
|
|
switch (code.code) {
|
|
|
case self.START_CODE_A:
|
|
|
codeset = self.CODE_A;
|
|
|
break;
|
|
|
case self.START_CODE_B:
|
|
|
codeset = self.CODE_B;
|
|
|
break;
|
|
|
case self.START_CODE_C:
|
|
|
codeset = self.CODE_C;
|
|
|
break;
|
|
|
default:
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
while (!done) {
|
|
|
unshift = shiftNext;
|
|
|
shiftNext = false;
|
|
|
code = self._decodeCode(code.end, code.correction);
|
|
|
if (code !== null) {
|
|
|
if (code.code !== self.STOP_CODE) {
|
|
|
removeLastCharacter = true;
|
|
|
}
|
|
|
|
|
|
if (code.code !== self.STOP_CODE) {
|
|
|
rawResult.push(code.code);
|
|
|
multiplier++;
|
|
|
checksum += multiplier * code.code;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
|
|
|
switch (codeset) {
|
|
|
case self.CODE_A:
|
|
|
if (code.code < 64) {
|
|
|
result.push(String.fromCharCode(32 + code.code));
|
|
|
} else if (code.code < 96) {
|
|
|
result.push(String.fromCharCode(code.code - 64));
|
|
|
} else {
|
|
|
if (code.code !== self.STOP_CODE) {
|
|
|
removeLastCharacter = false;
|
|
|
}
|
|
|
switch (code.code) {
|
|
|
case self.CODE_SHIFT:
|
|
|
shiftNext = true;
|
|
|
codeset = self.CODE_B;
|
|
|
break;
|
|
|
case self.CODE_B:
|
|
|
codeset = self.CODE_B;
|
|
|
break;
|
|
|
case self.CODE_C:
|
|
|
codeset = self.CODE_C;
|
|
|
break;
|
|
|
case self.STOP_CODE:
|
|
|
done = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case self.CODE_B:
|
|
|
if (code.code < 96) {
|
|
|
result.push(String.fromCharCode(32 + code.code));
|
|
|
} else {
|
|
|
if (code.code !== self.STOP_CODE) {
|
|
|
removeLastCharacter = false;
|
|
|
}
|
|
|
switch (code.code) {
|
|
|
case self.CODE_SHIFT:
|
|
|
shiftNext = true;
|
|
|
codeset = self.CODE_A;
|
|
|
break;
|
|
|
case self.CODE_A:
|
|
|
codeset = self.CODE_A;
|
|
|
break;
|
|
|
case self.CODE_C:
|
|
|
codeset = self.CODE_C;
|
|
|
break;
|
|
|
case self.STOP_CODE:
|
|
|
done = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case self.CODE_C:
|
|
|
if (code.code < 100) {
|
|
|
result.push(code.code < 10 ? "0" + code.code : code.code);
|
|
|
} else {
|
|
|
if (code.code !== self.STOP_CODE) {
|
|
|
removeLastCharacter = false;
|
|
|
}
|
|
|
switch (code.code) {
|
|
|
case self.CODE_A:
|
|
|
codeset = self.CODE_A;
|
|
|
break;
|
|
|
case self.CODE_B:
|
|
|
codeset = self.CODE_B;
|
|
|
break;
|
|
|
case self.STOP_CODE:
|
|
|
done = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
} else {
|
|
|
done = true;
|
|
|
}
|
|
|
if (unshift) {
|
|
|
codeset = codeset === self.CODE_A ? self.CODE_B : self.CODE_A;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (code === null) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
code.end = self._nextUnset(self._row, code.end);
|
|
|
if (!self._verifyTrailingWhitespace(code)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
checksum -= multiplier * rawResult[rawResult.length - 1];
|
|
|
if (checksum % 103 !== rawResult[rawResult.length - 1]) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (!result.length) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
// remove last code from result (checksum)
|
|
|
if (removeLastCharacter) {
|
|
|
result.splice(result.length - 1, 1);
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
code: result.join(""),
|
|
|
start: startInfo.start,
|
|
|
end: code.end,
|
|
|
codeset: codeset,
|
|
|
startInfo: startInfo,
|
|
|
decodedCodes: decodedCodes,
|
|
|
endInfo: code
|
|
|
};
|
|
|
};
|
|
|
|
|
|
_barcode_reader2.default.prototype._verifyTrailingWhitespace = function (endInfo) {
|
|
|
var self = this,
|
|
|
trailingWhitespaceEnd;
|
|
|
|
|
|
trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
|
|
|
if (trailingWhitespaceEnd < self._row.length) {
|
|
|
if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
|
|
|
return endInfo;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
function calculateCorrection(expected, normalized, indices) {
|
|
|
var length = indices.length,
|
|
|
sumNormalized = 0,
|
|
|
sumExpected = 0;
|
|
|
|
|
|
while (length--) {
|
|
|
sumExpected += expected[indices[length]];
|
|
|
sumNormalized += normalized[indices[length]];
|
|
|
}
|
|
|
return sumExpected / sumNormalized;
|
|
|
}
|
|
|
|
|
|
exports.default = Code128Reader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 90 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _code_39_reader = __webpack_require__(43);
|
|
|
|
|
|
var _code_39_reader2 = _interopRequireDefault(_code_39_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function Code39VINReader() {
|
|
|
_code_39_reader2.default.call(this);
|
|
|
}
|
|
|
|
|
|
var patterns = {
|
|
|
IOQ: /[IOQ]/g,
|
|
|
AZ09: /[A-Z0-9]{17}/
|
|
|
};
|
|
|
|
|
|
Code39VINReader.prototype = Object.create(_code_39_reader2.default.prototype);
|
|
|
Code39VINReader.prototype.constructor = Code39VINReader;
|
|
|
|
|
|
// Cribbed from:
|
|
|
// https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java
|
|
|
Code39VINReader.prototype._decode = function () {
|
|
|
var result = _code_39_reader2.default.prototype._decode.apply(this);
|
|
|
if (!result) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
var code = result.code;
|
|
|
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
code = code.replace(patterns.IOQ, '');
|
|
|
|
|
|
if (!code.match(patterns.AZ09)) {
|
|
|
if (false) {
|
|
|
console.log('Failed AZ09 pattern code:', code);
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (!this._checkChecksum(code)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
result.code = code;
|
|
|
return result;
|
|
|
};
|
|
|
|
|
|
Code39VINReader.prototype._checkChecksum = function (code) {
|
|
|
// TODO
|
|
|
return !!code;
|
|
|
};
|
|
|
|
|
|
exports.default = Code39VINReader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 91 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _ean_reader = __webpack_require__(5);
|
|
|
|
|
|
var _ean_reader2 = _interopRequireDefault(_ean_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function EAN2Reader() {
|
|
|
_ean_reader2.default.call(this);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
FORMAT: { value: "ean_2", writeable: false }
|
|
|
};
|
|
|
|
|
|
EAN2Reader.prototype = Object.create(_ean_reader2.default.prototype, properties);
|
|
|
EAN2Reader.prototype.constructor = EAN2Reader;
|
|
|
|
|
|
EAN2Reader.prototype.decode = function (row, start) {
|
|
|
this._row = row;
|
|
|
var counters = [0, 0, 0, 0],
|
|
|
codeFrequency = 0,
|
|
|
i = 0,
|
|
|
offset = start,
|
|
|
end = this._row.length,
|
|
|
code,
|
|
|
result = [],
|
|
|
decodedCodes = [];
|
|
|
|
|
|
for (i = 0; i < 2 && offset < end; i++) {
|
|
|
code = this._decodeCode(offset);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
result.push(code.code % 10);
|
|
|
if (code.code >= this.CODE_G_START) {
|
|
|
codeFrequency |= 1 << 1 - i;
|
|
|
}
|
|
|
if (i != 1) {
|
|
|
offset = this._nextSet(this._row, code.end);
|
|
|
offset = this._nextUnset(this._row, offset);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (result.length != 2 || parseInt(result.join("")) % 4 !== codeFrequency) {
|
|
|
return null;
|
|
|
}
|
|
|
return {
|
|
|
code: result.join(""),
|
|
|
decodedCodes: decodedCodes,
|
|
|
end: code.end
|
|
|
};
|
|
|
};
|
|
|
|
|
|
exports.default = EAN2Reader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 92 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _ean_reader = __webpack_require__(5);
|
|
|
|
|
|
var _ean_reader2 = _interopRequireDefault(_ean_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function EAN5Reader() {
|
|
|
_ean_reader2.default.call(this);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
FORMAT: { value: "ean_5", writeable: false }
|
|
|
};
|
|
|
|
|
|
var CHECK_DIGIT_ENCODINGS = [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];
|
|
|
|
|
|
EAN5Reader.prototype = Object.create(_ean_reader2.default.prototype, properties);
|
|
|
EAN5Reader.prototype.constructor = EAN5Reader;
|
|
|
|
|
|
EAN5Reader.prototype.decode = function (row, start) {
|
|
|
this._row = row;
|
|
|
var counters = [0, 0, 0, 0],
|
|
|
codeFrequency = 0,
|
|
|
i = 0,
|
|
|
offset = start,
|
|
|
end = this._row.length,
|
|
|
code,
|
|
|
result = [],
|
|
|
decodedCodes = [];
|
|
|
|
|
|
for (i = 0; i < 5 && offset < end; i++) {
|
|
|
code = this._decodeCode(offset);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
result.push(code.code % 10);
|
|
|
if (code.code >= this.CODE_G_START) {
|
|
|
codeFrequency |= 1 << 4 - i;
|
|
|
}
|
|
|
if (i != 4) {
|
|
|
offset = this._nextSet(this._row, code.end);
|
|
|
offset = this._nextUnset(this._row, offset);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (result.length != 5) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (extensionChecksum(result) !== determineCheckDigit(codeFrequency)) {
|
|
|
return null;
|
|
|
}
|
|
|
return {
|
|
|
code: result.join(""),
|
|
|
decodedCodes: decodedCodes,
|
|
|
end: code.end
|
|
|
};
|
|
|
};
|
|
|
|
|
|
function determineCheckDigit(codeFrequency) {
|
|
|
var i;
|
|
|
for (i = 0; i < 10; i++) {
|
|
|
if (codeFrequency === CHECK_DIGIT_ENCODINGS[i]) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
function extensionChecksum(result) {
|
|
|
var length = result.length,
|
|
|
sum = 0,
|
|
|
i;
|
|
|
|
|
|
for (i = length - 2; i >= 0; i -= 2) {
|
|
|
sum += result[i];
|
|
|
}
|
|
|
sum *= 3;
|
|
|
for (i = length - 1; i >= 0; i -= 2) {
|
|
|
sum += result[i];
|
|
|
}
|
|
|
sum *= 3;
|
|
|
return sum % 10;
|
|
|
}
|
|
|
|
|
|
exports.default = EAN5Reader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 93 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _ean_reader = __webpack_require__(5);
|
|
|
|
|
|
var _ean_reader2 = _interopRequireDefault(_ean_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function EAN8Reader(opts, supplements) {
|
|
|
_ean_reader2.default.call(this, opts, supplements);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
FORMAT: { value: "ean_8", writeable: false }
|
|
|
};
|
|
|
|
|
|
EAN8Reader.prototype = Object.create(_ean_reader2.default.prototype, properties);
|
|
|
EAN8Reader.prototype.constructor = EAN8Reader;
|
|
|
|
|
|
EAN8Reader.prototype._decodePayload = function (code, result, decodedCodes) {
|
|
|
var i,
|
|
|
self = this;
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
code = self._decodeCode(code.end, self.CODE_G_START);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
result.push(code.code);
|
|
|
decodedCodes.push(code);
|
|
|
}
|
|
|
|
|
|
code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);
|
|
|
if (code === null) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
code = self._decodeCode(code.end, self.CODE_G_START);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(code);
|
|
|
result.push(code.code);
|
|
|
}
|
|
|
|
|
|
return code;
|
|
|
};
|
|
|
|
|
|
exports.default = EAN8Reader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 94 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _merge2 = __webpack_require__(40);
|
|
|
|
|
|
var _merge3 = _interopRequireDefault(_merge2);
|
|
|
|
|
|
var _barcode_reader = __webpack_require__(10);
|
|
|
|
|
|
var _barcode_reader2 = _interopRequireDefault(_barcode_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function I2of5Reader(opts) {
|
|
|
opts = (0, _merge3.default)(getDefaulConfig(), opts);
|
|
|
_barcode_reader2.default.call(this, opts);
|
|
|
this.barSpaceRatio = [1, 1];
|
|
|
if (opts.normalizeBarSpaceWidth) {
|
|
|
this.SINGLE_CODE_ERROR = 0.38;
|
|
|
this.AVG_CODE_ERROR = 0.09;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function getDefaulConfig() {
|
|
|
var config = {};
|
|
|
|
|
|
Object.keys(I2of5Reader.CONFIG_KEYS).forEach(function (key) {
|
|
|
config[key] = I2of5Reader.CONFIG_KEYS[key].default;
|
|
|
});
|
|
|
return config;
|
|
|
}
|
|
|
|
|
|
var N = 1,
|
|
|
W = 3,
|
|
|
properties = {
|
|
|
START_PATTERN: { value: [N, N, N, N] },
|
|
|
STOP_PATTERN: { value: [N, N, W] },
|
|
|
CODE_PATTERN: { value: [[N, N, W, W, N], [W, N, N, N, W], [N, W, N, N, W], [W, W, N, N, N], [N, N, W, N, W], [W, N, W, N, N], [N, W, W, N, N], [N, N, N, W, W], [W, N, N, W, N], [N, W, N, W, N]] },
|
|
|
SINGLE_CODE_ERROR: { value: 0.78, writable: true },
|
|
|
AVG_CODE_ERROR: { value: 0.38, writable: true },
|
|
|
MAX_CORRECTION_FACTOR: { value: 5 },
|
|
|
FORMAT: { value: "i2of5" }
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype = Object.create(_barcode_reader2.default.prototype, properties);
|
|
|
I2of5Reader.prototype.constructor = I2of5Reader;
|
|
|
|
|
|
I2of5Reader.prototype._matchPattern = function (counter, code) {
|
|
|
if (this.config.normalizeBarSpaceWidth) {
|
|
|
var i,
|
|
|
counterSum = [0, 0],
|
|
|
codeSum = [0, 0],
|
|
|
correction = [0, 0],
|
|
|
correctionRatio = this.MAX_CORRECTION_FACTOR,
|
|
|
correctionRatioInverse = 1 / correctionRatio;
|
|
|
|
|
|
for (i = 0; i < counter.length; i++) {
|
|
|
counterSum[i % 2] += counter[i];
|
|
|
codeSum[i % 2] += code[i];
|
|
|
}
|
|
|
correction[0] = codeSum[0] / counterSum[0];
|
|
|
correction[1] = codeSum[1] / counterSum[1];
|
|
|
|
|
|
correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);
|
|
|
correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);
|
|
|
this.barSpaceRatio = correction;
|
|
|
for (i = 0; i < counter.length; i++) {
|
|
|
counter[i] *= this.barSpaceRatio[i % 2];
|
|
|
}
|
|
|
}
|
|
|
return _barcode_reader2.default.prototype._matchPattern.call(this, counter, code);
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._findPattern = function (pattern, offset, isWhite, tryHarder) {
|
|
|
var counter = [],
|
|
|
self = this,
|
|
|
i,
|
|
|
counterPos = 0,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: 0,
|
|
|
end: 0
|
|
|
},
|
|
|
error,
|
|
|
j,
|
|
|
sum,
|
|
|
normalized,
|
|
|
epsilon = self.AVG_CODE_ERROR;
|
|
|
|
|
|
isWhite = isWhite || false;
|
|
|
tryHarder = tryHarder || false;
|
|
|
|
|
|
if (!offset) {
|
|
|
offset = self._nextSet(self._row);
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < pattern.length; i++) {
|
|
|
counter[i] = 0;
|
|
|
}
|
|
|
|
|
|
for (i = offset; i < self._row.length; i++) {
|
|
|
if (self._row[i] ^ isWhite) {
|
|
|
counter[counterPos]++;
|
|
|
} else {
|
|
|
if (counterPos === counter.length - 1) {
|
|
|
sum = 0;
|
|
|
for (j = 0; j < counter.length; j++) {
|
|
|
sum += counter[j];
|
|
|
}
|
|
|
error = self._matchPattern(counter, pattern);
|
|
|
if (error < epsilon) {
|
|
|
bestMatch.error = error;
|
|
|
bestMatch.start = i - sum;
|
|
|
bestMatch.end = i;
|
|
|
return bestMatch;
|
|
|
}
|
|
|
if (tryHarder) {
|
|
|
for (j = 0; j < counter.length - 2; j++) {
|
|
|
counter[j] = counter[j + 2];
|
|
|
}
|
|
|
counter[counter.length - 2] = 0;
|
|
|
counter[counter.length - 1] = 0;
|
|
|
counterPos--;
|
|
|
} else {
|
|
|
return null;
|
|
|
}
|
|
|
} else {
|
|
|
counterPos++;
|
|
|
}
|
|
|
counter[counterPos] = 1;
|
|
|
isWhite = !isWhite;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._findStart = function () {
|
|
|
var self = this,
|
|
|
leadingWhitespaceStart,
|
|
|
offset = self._nextSet(self._row),
|
|
|
startInfo,
|
|
|
narrowBarWidth = 1;
|
|
|
|
|
|
while (!startInfo) {
|
|
|
startInfo = self._findPattern(self.START_PATTERN, offset, false, true);
|
|
|
if (!startInfo) {
|
|
|
return null;
|
|
|
}
|
|
|
narrowBarWidth = Math.floor((startInfo.end - startInfo.start) / 4);
|
|
|
leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;
|
|
|
if (leadingWhitespaceStart >= 0) {
|
|
|
if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
|
|
|
return startInfo;
|
|
|
}
|
|
|
}
|
|
|
offset = startInfo.end;
|
|
|
startInfo = null;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._verifyTrailingWhitespace = function (endInfo) {
|
|
|
var self = this,
|
|
|
trailingWhitespaceEnd;
|
|
|
|
|
|
trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
|
|
|
if (trailingWhitespaceEnd < self._row.length) {
|
|
|
if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
|
|
|
return endInfo;
|
|
|
}
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._findEnd = function () {
|
|
|
var self = this,
|
|
|
endInfo,
|
|
|
tmp;
|
|
|
|
|
|
self._row.reverse();
|
|
|
endInfo = self._findPattern(self.STOP_PATTERN);
|
|
|
self._row.reverse();
|
|
|
|
|
|
if (endInfo === null) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
// reverse numbers
|
|
|
tmp = endInfo.start;
|
|
|
endInfo.start = self._row.length - endInfo.end;
|
|
|
endInfo.end = self._row.length - tmp;
|
|
|
|
|
|
return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._decodePair = function (counterPair) {
|
|
|
var i,
|
|
|
code,
|
|
|
codes = [],
|
|
|
self = this;
|
|
|
|
|
|
for (i = 0; i < counterPair.length; i++) {
|
|
|
code = self._decodeCode(counterPair[i]);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
codes.push(code);
|
|
|
}
|
|
|
return codes;
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._decodeCode = function (counter) {
|
|
|
var j,
|
|
|
self = this,
|
|
|
sum = 0,
|
|
|
normalized,
|
|
|
error,
|
|
|
epsilon = self.AVG_CODE_ERROR,
|
|
|
code,
|
|
|
bestMatch = {
|
|
|
error: Number.MAX_VALUE,
|
|
|
code: -1,
|
|
|
start: 0,
|
|
|
end: 0
|
|
|
};
|
|
|
|
|
|
for (j = 0; j < counter.length; j++) {
|
|
|
sum += counter[j];
|
|
|
}
|
|
|
for (code = 0; code < self.CODE_PATTERN.length; code++) {
|
|
|
error = self._matchPattern(counter, self.CODE_PATTERN[code]);
|
|
|
if (error < bestMatch.error) {
|
|
|
bestMatch.code = code;
|
|
|
bestMatch.error = error;
|
|
|
}
|
|
|
}
|
|
|
if (bestMatch.error < epsilon) {
|
|
|
return bestMatch;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._decodePayload = function (counters, result, decodedCodes) {
|
|
|
var i,
|
|
|
self = this,
|
|
|
pos = 0,
|
|
|
counterLength = counters.length,
|
|
|
counterPair = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],
|
|
|
codes;
|
|
|
|
|
|
while (pos < counterLength) {
|
|
|
for (i = 0; i < 5; i++) {
|
|
|
counterPair[0][i] = counters[pos] * this.barSpaceRatio[0];
|
|
|
counterPair[1][i] = counters[pos + 1] * this.barSpaceRatio[1];
|
|
|
pos += 2;
|
|
|
}
|
|
|
codes = self._decodePair(counterPair);
|
|
|
if (!codes) {
|
|
|
return null;
|
|
|
}
|
|
|
for (i = 0; i < codes.length; i++) {
|
|
|
result.push(codes[i].code + "");
|
|
|
decodedCodes.push(codes[i]);
|
|
|
}
|
|
|
}
|
|
|
return codes;
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._verifyCounterLength = function (counters) {
|
|
|
return counters.length % 10 === 0;
|
|
|
};
|
|
|
|
|
|
I2of5Reader.prototype._decode = function () {
|
|
|
var startInfo,
|
|
|
endInfo,
|
|
|
self = this,
|
|
|
code,
|
|
|
result = [],
|
|
|
decodedCodes = [],
|
|
|
counters;
|
|
|
|
|
|
startInfo = self._findStart();
|
|
|
if (!startInfo) {
|
|
|
return null;
|
|
|
}
|
|
|
decodedCodes.push(startInfo);
|
|
|
|
|
|
endInfo = self._findEnd();
|
|
|
if (!endInfo) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
counters = self._fillCounters(startInfo.end, endInfo.start, false);
|
|
|
if (!self._verifyCounterLength(counters)) {
|
|
|
return null;
|
|
|
}
|
|
|
code = self._decodePayload(counters, result, decodedCodes);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
if (result.length % 2 !== 0 || result.length < 6) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
decodedCodes.push(endInfo);
|
|
|
return {
|
|
|
code: result.join(""),
|
|
|
start: startInfo.start,
|
|
|
end: endInfo.end,
|
|
|
startInfo: startInfo,
|
|
|
decodedCodes: decodedCodes
|
|
|
};
|
|
|
};
|
|
|
|
|
|
I2of5Reader.CONFIG_KEYS = {
|
|
|
normalizeBarSpaceWidth: {
|
|
|
'type': 'boolean',
|
|
|
'default': false,
|
|
|
'description': 'If true, the reader tries to normalize the' + 'width-difference between bars and spaces'
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = I2of5Reader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 95 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _ean_reader = __webpack_require__(5);
|
|
|
|
|
|
var _ean_reader2 = _interopRequireDefault(_ean_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function UPCEReader(opts, supplements) {
|
|
|
_ean_reader2.default.call(this, opts, supplements);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
CODE_FREQUENCY: { value: [[56, 52, 50, 49, 44, 38, 35, 42, 41, 37], [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]] },
|
|
|
STOP_PATTERN: { value: [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7] },
|
|
|
FORMAT: { value: "upc_e", writeable: false }
|
|
|
};
|
|
|
|
|
|
UPCEReader.prototype = Object.create(_ean_reader2.default.prototype, properties);
|
|
|
UPCEReader.prototype.constructor = UPCEReader;
|
|
|
|
|
|
UPCEReader.prototype._decodePayload = function (code, result, decodedCodes) {
|
|
|
var i,
|
|
|
self = this,
|
|
|
codeFrequency = 0x0;
|
|
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
code = self._decodeCode(code.end);
|
|
|
if (!code) {
|
|
|
return null;
|
|
|
}
|
|
|
if (code.code >= self.CODE_G_START) {
|
|
|
code.code = code.code - self.CODE_G_START;
|
|
|
codeFrequency |= 1 << 5 - i;
|
|
|
}
|
|
|
result.push(code.code);
|
|
|
decodedCodes.push(code);
|
|
|
}
|
|
|
if (!self._determineParity(codeFrequency, result)) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
return code;
|
|
|
};
|
|
|
|
|
|
UPCEReader.prototype._determineParity = function (codeFrequency, result) {
|
|
|
var i, nrSystem;
|
|
|
|
|
|
for (nrSystem = 0; nrSystem < this.CODE_FREQUENCY.length; nrSystem++) {
|
|
|
for (i = 0; i < this.CODE_FREQUENCY[nrSystem].length; i++) {
|
|
|
if (codeFrequency === this.CODE_FREQUENCY[nrSystem][i]) {
|
|
|
result.unshift(nrSystem);
|
|
|
result.push(i);
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
};
|
|
|
|
|
|
UPCEReader.prototype._convertToUPCA = function (result) {
|
|
|
var upca = [result[0]],
|
|
|
lastDigit = result[result.length - 2];
|
|
|
|
|
|
if (lastDigit <= 2) {
|
|
|
upca = upca.concat(result.slice(1, 3)).concat([lastDigit, 0, 0, 0, 0]).concat(result.slice(3, 6));
|
|
|
} else if (lastDigit === 3) {
|
|
|
upca = upca.concat(result.slice(1, 4)).concat([0, 0, 0, 0, 0]).concat(result.slice(4, 6));
|
|
|
} else if (lastDigit === 4) {
|
|
|
upca = upca.concat(result.slice(1, 5)).concat([0, 0, 0, 0, 0, result[5]]);
|
|
|
} else {
|
|
|
upca = upca.concat(result.slice(1, 6)).concat([0, 0, 0, 0, lastDigit]);
|
|
|
}
|
|
|
|
|
|
upca.push(result[result.length - 1]);
|
|
|
return upca;
|
|
|
};
|
|
|
|
|
|
UPCEReader.prototype._checksum = function (result) {
|
|
|
return _ean_reader2.default.prototype._checksum.call(this, this._convertToUPCA(result));
|
|
|
};
|
|
|
|
|
|
UPCEReader.prototype._findEnd = function (offset, isWhite) {
|
|
|
isWhite = true;
|
|
|
return _ean_reader2.default.prototype._findEnd.call(this, offset, isWhite);
|
|
|
};
|
|
|
|
|
|
UPCEReader.prototype._verifyTrailingWhitespace = function (endInfo) {
|
|
|
var self = this,
|
|
|
trailingWhitespaceEnd;
|
|
|
|
|
|
trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
|
|
|
if (trailingWhitespaceEnd < self._row.length) {
|
|
|
if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
|
|
|
return endInfo;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
exports.default = UPCEReader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 96 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
|
|
var _ean_reader = __webpack_require__(5);
|
|
|
|
|
|
var _ean_reader2 = _interopRequireDefault(_ean_reader);
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
function UPCReader(opts, supplements) {
|
|
|
_ean_reader2.default.call(this, opts, supplements);
|
|
|
}
|
|
|
|
|
|
var properties = {
|
|
|
FORMAT: { value: "upc_a", writeable: false }
|
|
|
};
|
|
|
|
|
|
UPCReader.prototype = Object.create(_ean_reader2.default.prototype, properties);
|
|
|
UPCReader.prototype.constructor = UPCReader;
|
|
|
|
|
|
UPCReader.prototype._decode = function () {
|
|
|
var result = _ean_reader2.default.prototype._decode.call(this);
|
|
|
|
|
|
if (result && result.code && result.code.length === 13 && result.code.charAt(0) === "0") {
|
|
|
result.code = result.code.substring(1);
|
|
|
return result;
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
|
|
|
exports.default = UPCReader;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 97 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = copy
|
|
|
|
|
|
/**
|
|
|
* Copy the values from one mat2 to another
|
|
|
*
|
|
|
* @alias mat2.copy
|
|
|
* @param {mat2} out the receiving matrix
|
|
|
* @param {mat2} a the source matrix
|
|
|
* @returns {mat2} out
|
|
|
*/
|
|
|
function copy(out, a) {
|
|
|
out[0] = a[0]
|
|
|
out[1] = a[1]
|
|
|
out[2] = a[2]
|
|
|
out[3] = a[3]
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 98 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = create
|
|
|
|
|
|
/**
|
|
|
* Creates a new identity mat2
|
|
|
*
|
|
|
* @alias mat2.create
|
|
|
* @returns {mat2} a new 2x2 matrix
|
|
|
*/
|
|
|
function create() {
|
|
|
var out = new Float32Array(4)
|
|
|
out[0] = 1
|
|
|
out[1] = 0
|
|
|
out[2] = 0
|
|
|
out[3] = 1
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 99 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = invert
|
|
|
|
|
|
/**
|
|
|
* Inverts a mat2
|
|
|
*
|
|
|
* @alias mat2.invert
|
|
|
* @param {mat2} out the receiving matrix
|
|
|
* @param {mat2} a the source matrix
|
|
|
* @returns {mat2} out
|
|
|
*/
|
|
|
function invert(out, a) {
|
|
|
var a0 = a[0]
|
|
|
var a1 = a[1]
|
|
|
var a2 = a[2]
|
|
|
var a3 = a[3]
|
|
|
var det = a0 * a3 - a2 * a1
|
|
|
|
|
|
if (!det) return null
|
|
|
det = 1.0 / det
|
|
|
|
|
|
out[0] = a3 * det
|
|
|
out[1] = -a1 * det
|
|
|
out[2] = -a2 * det
|
|
|
out[3] = a0 * det
|
|
|
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 100 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = scale
|
|
|
|
|
|
/**
|
|
|
* Scales a vec2 by a scalar number
|
|
|
*
|
|
|
* @param {vec2} out the receiving vector
|
|
|
* @param {vec2} a the vector to scale
|
|
|
* @param {Number} b amount to scale the vector by
|
|
|
* @returns {vec2} out
|
|
|
*/
|
|
|
function scale(out, a, b) {
|
|
|
out[0] = a[0] * b
|
|
|
out[1] = a[1] * b
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 101 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = transformMat2
|
|
|
|
|
|
/**
|
|
|
* Transforms the vec2 with a mat2
|
|
|
*
|
|
|
* @param {vec2} out the receiving vector
|
|
|
* @param {vec2} a the vector to transform
|
|
|
* @param {mat2} m matrix to transform with
|
|
|
* @returns {vec2} out
|
|
|
*/
|
|
|
function transformMat2(out, a, m) {
|
|
|
var x = a[0],
|
|
|
y = a[1]
|
|
|
out[0] = m[0] * x + m[2] * y
|
|
|
out[1] = m[1] * x + m[3] * y
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 102 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = clone;
|
|
|
|
|
|
/**
|
|
|
* Creates a new vec3 initialized with values from an existing vector
|
|
|
*
|
|
|
* @param {vec3} a vector to clone
|
|
|
* @returns {vec3} a new 3D vector
|
|
|
*/
|
|
|
function clone(a) {
|
|
|
var out = new Float32Array(3)
|
|
|
out[0] = a[0]
|
|
|
out[1] = a[1]
|
|
|
out[2] = a[2]
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 103 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4),
|
|
|
root = __webpack_require__(1);
|
|
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
|
var DataView = getNative(root, 'DataView');
|
|
|
|
|
|
module.exports = DataView;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 104 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var hashClear = __webpack_require__(154),
|
|
|
hashDelete = __webpack_require__(155),
|
|
|
hashGet = __webpack_require__(156),
|
|
|
hashHas = __webpack_require__(157),
|
|
|
hashSet = __webpack_require__(158);
|
|
|
|
|
|
/**
|
|
|
* Creates a hash object.
|
|
|
*
|
|
|
* @private
|
|
|
* @constructor
|
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
|
|
*/
|
|
|
function Hash(entries) {
|
|
|
var index = -1,
|
|
|
length = entries == null ? 0 : entries.length;
|
|
|
|
|
|
this.clear();
|
|
|
while (++index < length) {
|
|
|
var entry = entries[index];
|
|
|
this.set(entry[0], entry[1]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Add methods to `Hash`.
|
|
|
Hash.prototype.clear = hashClear;
|
|
|
Hash.prototype['delete'] = hashDelete;
|
|
|
Hash.prototype.get = hashGet;
|
|
|
Hash.prototype.has = hashHas;
|
|
|
Hash.prototype.set = hashSet;
|
|
|
|
|
|
module.exports = Hash;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 105 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4),
|
|
|
root = __webpack_require__(1);
|
|
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
|
var Promise = getNative(root, 'Promise');
|
|
|
|
|
|
module.exports = Promise;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 106 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4),
|
|
|
root = __webpack_require__(1);
|
|
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
|
var Set = getNative(root, 'Set');
|
|
|
|
|
|
module.exports = Set;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 107 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var root = __webpack_require__(1);
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var Uint8Array = root.Uint8Array;
|
|
|
|
|
|
module.exports = Uint8Array;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 108 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getNative = __webpack_require__(4),
|
|
|
root = __webpack_require__(1);
|
|
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
|
var WeakMap = getNative(root, 'WeakMap');
|
|
|
|
|
|
module.exports = WeakMap;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 109 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Adds the key-value `pair` to `map`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} map The map to modify.
|
|
|
* @param {Array} pair The key-value pair to add.
|
|
|
* @returns {Object} Returns `map`.
|
|
|
*/
|
|
|
function addMapEntry(map, pair) {
|
|
|
// Don't return `map.set` because it's not chainable in IE 11.
|
|
|
map.set(pair[0], pair[1]);
|
|
|
return map;
|
|
|
}
|
|
|
|
|
|
module.exports = addMapEntry;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 110 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Adds `value` to `set`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} set The set to modify.
|
|
|
* @param {*} value The value to add.
|
|
|
* @returns {Object} Returns `set`.
|
|
|
*/
|
|
|
function addSetEntry(set, value) {
|
|
|
// Don't return `set.add` because it's not chainable in IE 11.
|
|
|
set.add(value);
|
|
|
return set;
|
|
|
}
|
|
|
|
|
|
module.exports = addSetEntry;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 111 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* A faster alternative to `Function#apply`, this function invokes `func`
|
|
|
* with the `this` binding of `thisArg` and the arguments of `args`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to invoke.
|
|
|
* @param {*} thisArg The `this` binding of `func`.
|
|
|
* @param {Array} args The arguments to invoke `func` with.
|
|
|
* @returns {*} Returns the result of `func`.
|
|
|
*/
|
|
|
function apply(func, thisArg, args) {
|
|
|
switch (args.length) {
|
|
|
case 0: return func.call(thisArg);
|
|
|
case 1: return func.call(thisArg, args[0]);
|
|
|
case 2: return func.call(thisArg, args[0], args[1]);
|
|
|
case 3: return func.call(thisArg, args[0], args[1], args[2]);
|
|
|
}
|
|
|
return func.apply(thisArg, args);
|
|
|
}
|
|
|
|
|
|
module.exports = apply;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 112 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `_.forEach` for arrays without support for
|
|
|
* iteratee shorthands.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} [array] The array to iterate over.
|
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
|
* @returns {Array} Returns `array`.
|
|
|
*/
|
|
|
function arrayEach(array, iteratee) {
|
|
|
var index = -1,
|
|
|
length = array == null ? 0 : array.length;
|
|
|
|
|
|
while (++index < length) {
|
|
|
if (iteratee(array[index], index, array) === false) {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
module.exports = arrayEach;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 113 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `_.filter` for arrays without support for
|
|
|
* iteratee shorthands.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} [array] The array to iterate over.
|
|
|
* @param {Function} predicate The function invoked per iteration.
|
|
|
* @returns {Array} Returns the new filtered array.
|
|
|
*/
|
|
|
function arrayFilter(array, predicate) {
|
|
|
var index = -1,
|
|
|
length = array == null ? 0 : array.length,
|
|
|
resIndex = 0,
|
|
|
result = [];
|
|
|
|
|
|
while (++index < length) {
|
|
|
var value = array[index];
|
|
|
if (predicate(value, index, array)) {
|
|
|
result[resIndex++] = value;
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = arrayFilter;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 114 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var copyObject = __webpack_require__(8),
|
|
|
keys = __webpack_require__(39);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.assign` without support for multiple sources
|
|
|
* or `customizer` functions.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The destination object.
|
|
|
* @param {Object} source The source object.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
function baseAssign(object, source) {
|
|
|
return object && copyObject(source, keys(source), object);
|
|
|
}
|
|
|
|
|
|
module.exports = baseAssign;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 115 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var copyObject = __webpack_require__(8),
|
|
|
keysIn = __webpack_require__(24);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.assignIn` without support for multiple sources
|
|
|
* or `customizer` functions.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The destination object.
|
|
|
* @param {Object} source The source object.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
function baseAssignIn(object, source) {
|
|
|
return object && copyObject(source, keysIn(source), object);
|
|
|
}
|
|
|
|
|
|
module.exports = baseAssignIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 116 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Stack = __webpack_require__(46),
|
|
|
arrayEach = __webpack_require__(112),
|
|
|
assignValue = __webpack_require__(29),
|
|
|
baseAssign = __webpack_require__(114),
|
|
|
baseAssignIn = __webpack_require__(115),
|
|
|
cloneBuffer = __webpack_require__(53),
|
|
|
copyArray = __webpack_require__(55),
|
|
|
copySymbols = __webpack_require__(143),
|
|
|
copySymbolsIn = __webpack_require__(144),
|
|
|
getAllKeys = __webpack_require__(149),
|
|
|
getAllKeysIn = __webpack_require__(59),
|
|
|
getTag = __webpack_require__(151),
|
|
|
initCloneArray = __webpack_require__(159),
|
|
|
initCloneByTag = __webpack_require__(160),
|
|
|
initCloneObject = __webpack_require__(61),
|
|
|
isArray = __webpack_require__(2),
|
|
|
isBuffer = __webpack_require__(35),
|
|
|
isObject = __webpack_require__(3),
|
|
|
keys = __webpack_require__(39);
|
|
|
|
|
|
/** Used to compose bitmasks for cloning. */
|
|
|
var CLONE_DEEP_FLAG = 1,
|
|
|
CLONE_FLAT_FLAG = 2,
|
|
|
CLONE_SYMBOLS_FLAG = 4;
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var argsTag = '[object Arguments]',
|
|
|
arrayTag = '[object Array]',
|
|
|
boolTag = '[object Boolean]',
|
|
|
dateTag = '[object Date]',
|
|
|
errorTag = '[object Error]',
|
|
|
funcTag = '[object Function]',
|
|
|
genTag = '[object GeneratorFunction]',
|
|
|
mapTag = '[object Map]',
|
|
|
numberTag = '[object Number]',
|
|
|
objectTag = '[object Object]',
|
|
|
regexpTag = '[object RegExp]',
|
|
|
setTag = '[object Set]',
|
|
|
stringTag = '[object String]',
|
|
|
symbolTag = '[object Symbol]',
|
|
|
weakMapTag = '[object WeakMap]';
|
|
|
|
|
|
var arrayBufferTag = '[object ArrayBuffer]',
|
|
|
dataViewTag = '[object DataView]',
|
|
|
float32Tag = '[object Float32Array]',
|
|
|
float64Tag = '[object Float64Array]',
|
|
|
int8Tag = '[object Int8Array]',
|
|
|
int16Tag = '[object Int16Array]',
|
|
|
int32Tag = '[object Int32Array]',
|
|
|
uint8Tag = '[object Uint8Array]',
|
|
|
uint8ClampedTag = '[object Uint8ClampedArray]',
|
|
|
uint16Tag = '[object Uint16Array]',
|
|
|
uint32Tag = '[object Uint32Array]';
|
|
|
|
|
|
/** Used to identify `toStringTag` values supported by `_.clone`. */
|
|
|
var cloneableTags = {};
|
|
|
cloneableTags[argsTag] = cloneableTags[arrayTag] =
|
|
|
cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
|
|
|
cloneableTags[boolTag] = cloneableTags[dateTag] =
|
|
|
cloneableTags[float32Tag] = cloneableTags[float64Tag] =
|
|
|
cloneableTags[int8Tag] = cloneableTags[int16Tag] =
|
|
|
cloneableTags[int32Tag] = cloneableTags[mapTag] =
|
|
|
cloneableTags[numberTag] = cloneableTags[objectTag] =
|
|
|
cloneableTags[regexpTag] = cloneableTags[setTag] =
|
|
|
cloneableTags[stringTag] = cloneableTags[symbolTag] =
|
|
|
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
|
|
|
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
|
|
|
cloneableTags[errorTag] = cloneableTags[funcTag] =
|
|
|
cloneableTags[weakMapTag] = false;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.clone` and `_.cloneDeep` which tracks
|
|
|
* traversed objects.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to clone.
|
|
|
* @param {boolean} bitmask The bitmask flags.
|
|
|
* 1 - Deep clone
|
|
|
* 2 - Flatten inherited properties
|
|
|
* 4 - Clone symbols
|
|
|
* @param {Function} [customizer] The function to customize cloning.
|
|
|
* @param {string} [key] The key of `value`.
|
|
|
* @param {Object} [object] The parent object of `value`.
|
|
|
* @param {Object} [stack] Tracks traversed objects and their clone counterparts.
|
|
|
* @returns {*} Returns the cloned value.
|
|
|
*/
|
|
|
function baseClone(value, bitmask, customizer, key, object, stack) {
|
|
|
var result,
|
|
|
isDeep = bitmask & CLONE_DEEP_FLAG,
|
|
|
isFlat = bitmask & CLONE_FLAT_FLAG,
|
|
|
isFull = bitmask & CLONE_SYMBOLS_FLAG;
|
|
|
|
|
|
if (customizer) {
|
|
|
result = object ? customizer(value, key, object, stack) : customizer(value);
|
|
|
}
|
|
|
if (result !== undefined) {
|
|
|
return result;
|
|
|
}
|
|
|
if (!isObject(value)) {
|
|
|
return value;
|
|
|
}
|
|
|
var isArr = isArray(value);
|
|
|
if (isArr) {
|
|
|
result = initCloneArray(value);
|
|
|
if (!isDeep) {
|
|
|
return copyArray(value, result);
|
|
|
}
|
|
|
} else {
|
|
|
var tag = getTag(value),
|
|
|
isFunc = tag == funcTag || tag == genTag;
|
|
|
|
|
|
if (isBuffer(value)) {
|
|
|
return cloneBuffer(value, isDeep);
|
|
|
}
|
|
|
if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
|
|
|
result = (isFlat || isFunc) ? {} : initCloneObject(value);
|
|
|
if (!isDeep) {
|
|
|
return isFlat
|
|
|
? copySymbolsIn(value, baseAssignIn(result, value))
|
|
|
: copySymbols(value, baseAssign(result, value));
|
|
|
}
|
|
|
} else {
|
|
|
if (!cloneableTags[tag]) {
|
|
|
return object ? value : {};
|
|
|
}
|
|
|
result = initCloneByTag(value, tag, baseClone, isDeep);
|
|
|
}
|
|
|
}
|
|
|
// Check for circular references and return its corresponding clone.
|
|
|
stack || (stack = new Stack);
|
|
|
var stacked = stack.get(value);
|
|
|
if (stacked) {
|
|
|
return stacked;
|
|
|
}
|
|
|
stack.set(value, result);
|
|
|
|
|
|
var keysFunc = isFull
|
|
|
? (isFlat ? getAllKeysIn : getAllKeys)
|
|
|
: (isFlat ? keysIn : keys);
|
|
|
|
|
|
var props = isArr ? undefined : keysFunc(value);
|
|
|
arrayEach(props || value, function(subValue, key) {
|
|
|
if (props) {
|
|
|
key = subValue;
|
|
|
subValue = value[key];
|
|
|
}
|
|
|
// Recursively populate clone (susceptible to call stack limits).
|
|
|
assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
|
|
|
});
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseClone;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 117 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isObject = __webpack_require__(3);
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var objectCreate = Object.create;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.create` without support for assigning
|
|
|
* properties to the created object.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} proto The object to inherit from.
|
|
|
* @returns {Object} Returns the new object.
|
|
|
*/
|
|
|
var baseCreate = (function() {
|
|
|
function object() {}
|
|
|
return function(proto) {
|
|
|
if (!isObject(proto)) {
|
|
|
return {};
|
|
|
}
|
|
|
if (objectCreate) {
|
|
|
return objectCreate(proto);
|
|
|
}
|
|
|
object.prototype = proto;
|
|
|
var result = new object;
|
|
|
object.prototype = undefined;
|
|
|
return result;
|
|
|
};
|
|
|
}());
|
|
|
|
|
|
module.exports = baseCreate;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 118 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayPush = __webpack_require__(28),
|
|
|
isFlattenable = __webpack_require__(161);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.flatten` with support for restricting flattening.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} array The array to flatten.
|
|
|
* @param {number} depth The maximum recursion depth.
|
|
|
* @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
|
|
|
* @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
|
|
|
* @param {Array} [result=[]] The initial result value.
|
|
|
* @returns {Array} Returns the new flattened array.
|
|
|
*/
|
|
|
function baseFlatten(array, depth, predicate, isStrict, result) {
|
|
|
var index = -1,
|
|
|
length = array.length;
|
|
|
|
|
|
predicate || (predicate = isFlattenable);
|
|
|
result || (result = []);
|
|
|
|
|
|
while (++index < length) {
|
|
|
var value = array[index];
|
|
|
if (depth > 0 && predicate(value)) {
|
|
|
if (depth > 1) {
|
|
|
// Recursively flatten arrays (susceptible to call stack limits).
|
|
|
baseFlatten(value, depth - 1, predicate, isStrict, result);
|
|
|
} else {
|
|
|
arrayPush(result, value);
|
|
|
}
|
|
|
} else if (!isStrict) {
|
|
|
result[result.length] = value;
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseFlatten;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 119 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var createBaseFor = __webpack_require__(147);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `baseForOwn` which iterates over `object`
|
|
|
* properties returned by `keysFunc` and invokes `iteratee` for each property.
|
|
|
* Iteratee functions may exit iteration early by explicitly returning `false`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to iterate over.
|
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
|
* @param {Function} keysFunc The function to get the keys of `object`.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
var baseFor = createBaseFor();
|
|
|
|
|
|
module.exports = baseFor;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 120 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.hasIn` without support for deep paths.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} [object] The object to query.
|
|
|
* @param {Array|string} key The key to check.
|
|
|
* @returns {boolean} Returns `true` if `key` exists, else `false`.
|
|
|
*/
|
|
|
function baseHasIn(object, key) {
|
|
|
return object != null && key in Object(object);
|
|
|
}
|
|
|
|
|
|
module.exports = baseHasIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 121 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
|
isObjectLike = __webpack_require__(9);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var argsTag = '[object Arguments]';
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.isArguments`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
|
|
|
*/
|
|
|
function baseIsArguments(value) {
|
|
|
return isObjectLike(value) && baseGetTag(value) == argsTag;
|
|
|
}
|
|
|
|
|
|
module.exports = baseIsArguments;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 122 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isFunction = __webpack_require__(36),
|
|
|
isMasked = __webpack_require__(165),
|
|
|
isObject = __webpack_require__(3),
|
|
|
toSource = __webpack_require__(65);
|
|
|
|
|
|
/**
|
|
|
* Used to match `RegExp`
|
|
|
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
|
|
|
*/
|
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
|
|
|
|
/** Used to detect host constructors (Safari). */
|
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var funcProto = Function.prototype,
|
|
|
objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to resolve the decompiled source of functions. */
|
|
|
var funcToString = funcProto.toString;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/** Used to detect if a method is native. */
|
|
|
var reIsNative = RegExp('^' +
|
|
|
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
|
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
|
|
);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.isNative` without bad shim checks.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a native function,
|
|
|
* else `false`.
|
|
|
*/
|
|
|
function baseIsNative(value) {
|
|
|
if (!isObject(value) || isMasked(value)) {
|
|
|
return false;
|
|
|
}
|
|
|
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
|
|
|
return pattern.test(toSource(value));
|
|
|
}
|
|
|
|
|
|
module.exports = baseIsNative;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 123 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
|
isLength = __webpack_require__(37),
|
|
|
isObjectLike = __webpack_require__(9);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var argsTag = '[object Arguments]',
|
|
|
arrayTag = '[object Array]',
|
|
|
boolTag = '[object Boolean]',
|
|
|
dateTag = '[object Date]',
|
|
|
errorTag = '[object Error]',
|
|
|
funcTag = '[object Function]',
|
|
|
mapTag = '[object Map]',
|
|
|
numberTag = '[object Number]',
|
|
|
objectTag = '[object Object]',
|
|
|
regexpTag = '[object RegExp]',
|
|
|
setTag = '[object Set]',
|
|
|
stringTag = '[object String]',
|
|
|
weakMapTag = '[object WeakMap]';
|
|
|
|
|
|
var arrayBufferTag = '[object ArrayBuffer]',
|
|
|
dataViewTag = '[object DataView]',
|
|
|
float32Tag = '[object Float32Array]',
|
|
|
float64Tag = '[object Float64Array]',
|
|
|
int8Tag = '[object Int8Array]',
|
|
|
int16Tag = '[object Int16Array]',
|
|
|
int32Tag = '[object Int32Array]',
|
|
|
uint8Tag = '[object Uint8Array]',
|
|
|
uint8ClampedTag = '[object Uint8ClampedArray]',
|
|
|
uint16Tag = '[object Uint16Array]',
|
|
|
uint32Tag = '[object Uint32Array]';
|
|
|
|
|
|
/** Used to identify `toStringTag` values of typed arrays. */
|
|
|
var typedArrayTags = {};
|
|
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
|
|
|
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
|
|
|
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
|
|
|
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
|
|
|
typedArrayTags[uint32Tag] = true;
|
|
|
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
|
|
|
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
|
|
|
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
|
|
|
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
|
|
|
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
|
|
|
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
|
|
|
typedArrayTags[setTag] = typedArrayTags[stringTag] =
|
|
|
typedArrayTags[weakMapTag] = false;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.isTypedArray` without Node.js optimizations.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
|
|
|
*/
|
|
|
function baseIsTypedArray(value) {
|
|
|
return isObjectLike(value) &&
|
|
|
isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
|
|
|
}
|
|
|
|
|
|
module.exports = baseIsTypedArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 124 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isPrototype = __webpack_require__(34),
|
|
|
nativeKeys = __webpack_require__(178);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names.
|
|
|
*/
|
|
|
function baseKeys(object) {
|
|
|
if (!isPrototype(object)) {
|
|
|
return nativeKeys(object);
|
|
|
}
|
|
|
var result = [];
|
|
|
for (var key in Object(object)) {
|
|
|
if (hasOwnProperty.call(object, key) && key != 'constructor') {
|
|
|
result.push(key);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseKeys;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 125 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isObject = __webpack_require__(3),
|
|
|
isPrototype = __webpack_require__(34),
|
|
|
nativeKeysIn = __webpack_require__(179);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names.
|
|
|
*/
|
|
|
function baseKeysIn(object) {
|
|
|
if (!isObject(object)) {
|
|
|
return nativeKeysIn(object);
|
|
|
}
|
|
|
var isProto = isPrototype(object),
|
|
|
result = [];
|
|
|
|
|
|
for (var key in object) {
|
|
|
if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
|
|
|
result.push(key);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseKeysIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 126 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Stack = __webpack_require__(46),
|
|
|
assignMergeValue = __webpack_require__(50),
|
|
|
baseFor = __webpack_require__(119),
|
|
|
baseMergeDeep = __webpack_require__(127),
|
|
|
isObject = __webpack_require__(3),
|
|
|
keysIn = __webpack_require__(24);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.merge` without support for multiple sources.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The destination object.
|
|
|
* @param {Object} source The source object.
|
|
|
* @param {number} srcIndex The index of `source`.
|
|
|
* @param {Function} [customizer] The function to customize merged values.
|
|
|
* @param {Object} [stack] Tracks traversed source values and their merged
|
|
|
* counterparts.
|
|
|
*/
|
|
|
function baseMerge(object, source, srcIndex, customizer, stack) {
|
|
|
if (object === source) {
|
|
|
return;
|
|
|
}
|
|
|
baseFor(source, function(srcValue, key) {
|
|
|
if (isObject(srcValue)) {
|
|
|
stack || (stack = new Stack);
|
|
|
baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
|
|
|
}
|
|
|
else {
|
|
|
var newValue = customizer
|
|
|
? customizer(object[key], srcValue, (key + ''), object, source, stack)
|
|
|
: undefined;
|
|
|
|
|
|
if (newValue === undefined) {
|
|
|
newValue = srcValue;
|
|
|
}
|
|
|
assignMergeValue(object, key, newValue);
|
|
|
}
|
|
|
}, keysIn);
|
|
|
}
|
|
|
|
|
|
module.exports = baseMerge;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 127 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assignMergeValue = __webpack_require__(50),
|
|
|
cloneBuffer = __webpack_require__(53),
|
|
|
cloneTypedArray = __webpack_require__(54),
|
|
|
copyArray = __webpack_require__(55),
|
|
|
initCloneObject = __webpack_require__(61),
|
|
|
isArguments = __webpack_require__(22),
|
|
|
isArray = __webpack_require__(2),
|
|
|
isArrayLikeObject = __webpack_require__(194),
|
|
|
isBuffer = __webpack_require__(35),
|
|
|
isFunction = __webpack_require__(36),
|
|
|
isObject = __webpack_require__(3),
|
|
|
isPlainObject = __webpack_require__(67),
|
|
|
isTypedArray = __webpack_require__(68),
|
|
|
toPlainObject = __webpack_require__(200);
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `baseMerge` for arrays and objects which performs
|
|
|
* deep merges and tracks traversed objects enabling objects with circular
|
|
|
* references to be merged.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The destination object.
|
|
|
* @param {Object} source The source object.
|
|
|
* @param {string} key The key of the value to merge.
|
|
|
* @param {number} srcIndex The index of `source`.
|
|
|
* @param {Function} mergeFunc The function to merge values.
|
|
|
* @param {Function} [customizer] The function to customize assigned values.
|
|
|
* @param {Object} [stack] Tracks traversed source values and their merged
|
|
|
* counterparts.
|
|
|
*/
|
|
|
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
|
|
|
var objValue = object[key],
|
|
|
srcValue = source[key],
|
|
|
stacked = stack.get(srcValue);
|
|
|
|
|
|
if (stacked) {
|
|
|
assignMergeValue(object, key, stacked);
|
|
|
return;
|
|
|
}
|
|
|
var newValue = customizer
|
|
|
? customizer(objValue, srcValue, (key + ''), object, source, stack)
|
|
|
: undefined;
|
|
|
|
|
|
var isCommon = newValue === undefined;
|
|
|
|
|
|
if (isCommon) {
|
|
|
var isArr = isArray(srcValue),
|
|
|
isBuff = !isArr && isBuffer(srcValue),
|
|
|
isTyped = !isArr && !isBuff && isTypedArray(srcValue);
|
|
|
|
|
|
newValue = srcValue;
|
|
|
if (isArr || isBuff || isTyped) {
|
|
|
if (isArray(objValue)) {
|
|
|
newValue = objValue;
|
|
|
}
|
|
|
else if (isArrayLikeObject(objValue)) {
|
|
|
newValue = copyArray(objValue);
|
|
|
}
|
|
|
else if (isBuff) {
|
|
|
isCommon = false;
|
|
|
newValue = cloneBuffer(srcValue, true);
|
|
|
}
|
|
|
else if (isTyped) {
|
|
|
isCommon = false;
|
|
|
newValue = cloneTypedArray(srcValue, true);
|
|
|
}
|
|
|
else {
|
|
|
newValue = [];
|
|
|
}
|
|
|
}
|
|
|
else if (isPlainObject(srcValue) || isArguments(srcValue)) {
|
|
|
newValue = objValue;
|
|
|
if (isArguments(objValue)) {
|
|
|
newValue = toPlainObject(objValue);
|
|
|
}
|
|
|
else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
|
|
|
newValue = initCloneObject(srcValue);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
isCommon = false;
|
|
|
}
|
|
|
}
|
|
|
if (isCommon) {
|
|
|
// Recursively merge objects and arrays (susceptible to call stack limits).
|
|
|
stack.set(srcValue, newValue);
|
|
|
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
|
|
|
stack['delete'](srcValue);
|
|
|
}
|
|
|
assignMergeValue(object, key, newValue);
|
|
|
}
|
|
|
|
|
|
module.exports = baseMergeDeep;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 128 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var basePickBy = __webpack_require__(129),
|
|
|
hasIn = __webpack_require__(193);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.pick` without support for individual
|
|
|
* property identifiers.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The source object.
|
|
|
* @param {string[]} paths The property paths to pick.
|
|
|
* @returns {Object} Returns the new object.
|
|
|
*/
|
|
|
function basePick(object, paths) {
|
|
|
return basePickBy(object, paths, function(value, path) {
|
|
|
return hasIn(object, path);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
module.exports = basePick;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 129 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGet = __webpack_require__(51),
|
|
|
baseSet = __webpack_require__(131),
|
|
|
castPath = __webpack_require__(7);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.pickBy` without support for iteratee shorthands.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The source object.
|
|
|
* @param {string[]} paths The property paths to pick.
|
|
|
* @param {Function} predicate The function invoked per property.
|
|
|
* @returns {Object} Returns the new object.
|
|
|
*/
|
|
|
function basePickBy(object, paths, predicate) {
|
|
|
var index = -1,
|
|
|
length = paths.length,
|
|
|
result = {};
|
|
|
|
|
|
while (++index < length) {
|
|
|
var path = paths[index],
|
|
|
value = baseGet(object, path);
|
|
|
|
|
|
if (predicate(value, path)) {
|
|
|
baseSet(result, castPath(path, object), value);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = basePickBy;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 130 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var identity = __webpack_require__(66),
|
|
|
overRest = __webpack_require__(63),
|
|
|
setToString = __webpack_require__(64);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.rest` which doesn't validate or coerce arguments.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to apply a rest parameter to.
|
|
|
* @param {number} [start=func.length-1] The start position of the rest parameter.
|
|
|
* @returns {Function} Returns the new function.
|
|
|
*/
|
|
|
function baseRest(func, start) {
|
|
|
return setToString(overRest(func, start, identity), func + '');
|
|
|
}
|
|
|
|
|
|
module.exports = baseRest;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 131 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assignValue = __webpack_require__(29),
|
|
|
castPath = __webpack_require__(7),
|
|
|
isIndex = __webpack_require__(18),
|
|
|
isObject = __webpack_require__(3),
|
|
|
toKey = __webpack_require__(20);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.set`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to modify.
|
|
|
* @param {Array|string} path The path of the property to set.
|
|
|
* @param {*} value The value to set.
|
|
|
* @param {Function} [customizer] The function to customize path creation.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
function baseSet(object, path, value, customizer) {
|
|
|
if (!isObject(object)) {
|
|
|
return object;
|
|
|
}
|
|
|
path = castPath(path, object);
|
|
|
|
|
|
var index = -1,
|
|
|
length = path.length,
|
|
|
lastIndex = length - 1,
|
|
|
nested = object;
|
|
|
|
|
|
while (nested != null && ++index < length) {
|
|
|
var key = toKey(path[index]),
|
|
|
newValue = value;
|
|
|
|
|
|
if (index != lastIndex) {
|
|
|
var objValue = nested[key];
|
|
|
newValue = customizer ? customizer(objValue, key, nested) : undefined;
|
|
|
if (newValue === undefined) {
|
|
|
newValue = isObject(objValue)
|
|
|
? objValue
|
|
|
: (isIndex(path[index + 1]) ? [] : {});
|
|
|
}
|
|
|
}
|
|
|
assignValue(nested, key, newValue);
|
|
|
nested = nested[key];
|
|
|
}
|
|
|
return object;
|
|
|
}
|
|
|
|
|
|
module.exports = baseSet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 132 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var constant = __webpack_require__(191),
|
|
|
defineProperty = __webpack_require__(56),
|
|
|
identity = __webpack_require__(66);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `setToString` without support for hot loop shorting.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to modify.
|
|
|
* @param {Function} string The `toString` result.
|
|
|
* @returns {Function} Returns `func`.
|
|
|
*/
|
|
|
var baseSetToString = !defineProperty ? identity : function(func, string) {
|
|
|
return defineProperty(func, 'toString', {
|
|
|
'configurable': true,
|
|
|
'enumerable': false,
|
|
|
'value': constant(string),
|
|
|
'writable': true
|
|
|
});
|
|
|
};
|
|
|
|
|
|
module.exports = baseSetToString;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 133 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.slice` without an iteratee call guard.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} array The array to slice.
|
|
|
* @param {number} [start=0] The start position.
|
|
|
* @param {number} [end=array.length] The end position.
|
|
|
* @returns {Array} Returns the slice of `array`.
|
|
|
*/
|
|
|
function baseSlice(array, start, end) {
|
|
|
var index = -1,
|
|
|
length = array.length;
|
|
|
|
|
|
if (start < 0) {
|
|
|
start = -start > length ? 0 : (length + start);
|
|
|
}
|
|
|
end = end > length ? length : end;
|
|
|
if (end < 0) {
|
|
|
end += length;
|
|
|
}
|
|
|
length = start > end ? 0 : ((end - start) >>> 0);
|
|
|
start >>>= 0;
|
|
|
|
|
|
var result = Array(length);
|
|
|
while (++index < length) {
|
|
|
result[index] = array[index + start];
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseSlice;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 134 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.times` without support for iteratee shorthands
|
|
|
* or max array length checks.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {number} n The number of times to invoke `iteratee`.
|
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
|
* @returns {Array} Returns the array of results.
|
|
|
*/
|
|
|
function baseTimes(n, iteratee) {
|
|
|
var index = -1,
|
|
|
result = Array(n);
|
|
|
|
|
|
while (++index < n) {
|
|
|
result[index] = iteratee(index);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseTimes;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 135 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Symbol = __webpack_require__(12),
|
|
|
arrayMap = __webpack_require__(48),
|
|
|
isArray = __webpack_require__(2),
|
|
|
isSymbol = __webpack_require__(38);
|
|
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
|
var INFINITY = 1 / 0;
|
|
|
|
|
|
/** Used to convert symbols to primitives and strings. */
|
|
|
var symbolProto = Symbol ? Symbol.prototype : undefined,
|
|
|
symbolToString = symbolProto ? symbolProto.toString : undefined;
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.toString` which doesn't convert nullish
|
|
|
* values to empty strings.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to process.
|
|
|
* @returns {string} Returns the string.
|
|
|
*/
|
|
|
function baseToString(value) {
|
|
|
// Exit early for strings to avoid a performance hit in some environments.
|
|
|
if (typeof value == 'string') {
|
|
|
return value;
|
|
|
}
|
|
|
if (isArray(value)) {
|
|
|
// Recursively convert values (susceptible to call stack limits).
|
|
|
return arrayMap(value, baseToString) + '';
|
|
|
}
|
|
|
if (isSymbol(value)) {
|
|
|
return symbolToString ? symbolToString.call(value) : '';
|
|
|
}
|
|
|
var result = (value + '');
|
|
|
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
|
|
|
}
|
|
|
|
|
|
module.exports = baseToString;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 136 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.unary` without support for storing metadata.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to cap arguments for.
|
|
|
* @returns {Function} Returns the new capped function.
|
|
|
*/
|
|
|
function baseUnary(func) {
|
|
|
return function(value) {
|
|
|
return func(value);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = baseUnary;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 137 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var castPath = __webpack_require__(7),
|
|
|
last = __webpack_require__(195),
|
|
|
parent = __webpack_require__(182),
|
|
|
toKey = __webpack_require__(20);
|
|
|
|
|
|
/**
|
|
|
* The base implementation of `_.unset`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to modify.
|
|
|
* @param {Array|string} path The property path to unset.
|
|
|
* @returns {boolean} Returns `true` if the property is deleted, else `false`.
|
|
|
*/
|
|
|
function baseUnset(object, path) {
|
|
|
path = castPath(path, object);
|
|
|
object = parent(object, path);
|
|
|
return object == null || delete object[toKey(last(path))];
|
|
|
}
|
|
|
|
|
|
module.exports = baseUnset;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 138 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var cloneArrayBuffer = __webpack_require__(31);
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `dataView`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} dataView The data view to clone.
|
|
|
* @param {boolean} [isDeep] Specify a deep clone.
|
|
|
* @returns {Object} Returns the cloned data view.
|
|
|
*/
|
|
|
function cloneDataView(dataView, isDeep) {
|
|
|
var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
|
|
|
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
|
|
|
}
|
|
|
|
|
|
module.exports = cloneDataView;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 139 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var addMapEntry = __webpack_require__(109),
|
|
|
arrayReduce = __webpack_require__(49),
|
|
|
mapToArray = __webpack_require__(176);
|
|
|
|
|
|
/** Used to compose bitmasks for cloning. */
|
|
|
var CLONE_DEEP_FLAG = 1;
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `map`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} map The map to clone.
|
|
|
* @param {Function} cloneFunc The function to clone values.
|
|
|
* @param {boolean} [isDeep] Specify a deep clone.
|
|
|
* @returns {Object} Returns the cloned map.
|
|
|
*/
|
|
|
function cloneMap(map, isDeep, cloneFunc) {
|
|
|
var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
|
|
|
return arrayReduce(array, addMapEntry, new map.constructor);
|
|
|
}
|
|
|
|
|
|
module.exports = cloneMap;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 140 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used to match `RegExp` flags from their coerced string values. */
|
|
|
var reFlags = /\w*$/;
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `regexp`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} regexp The regexp to clone.
|
|
|
* @returns {Object} Returns the cloned regexp.
|
|
|
*/
|
|
|
function cloneRegExp(regexp) {
|
|
|
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
|
|
|
result.lastIndex = regexp.lastIndex;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = cloneRegExp;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 141 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var addSetEntry = __webpack_require__(110),
|
|
|
arrayReduce = __webpack_require__(49),
|
|
|
setToArray = __webpack_require__(183);
|
|
|
|
|
|
/** Used to compose bitmasks for cloning. */
|
|
|
var CLONE_DEEP_FLAG = 1;
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of `set`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} set The set to clone.
|
|
|
* @param {Function} cloneFunc The function to clone values.
|
|
|
* @param {boolean} [isDeep] Specify a deep clone.
|
|
|
* @returns {Object} Returns the cloned set.
|
|
|
*/
|
|
|
function cloneSet(set, isDeep, cloneFunc) {
|
|
|
var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
|
|
|
return arrayReduce(array, addSetEntry, new set.constructor);
|
|
|
}
|
|
|
|
|
|
module.exports = cloneSet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 142 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Symbol = __webpack_require__(12);
|
|
|
|
|
|
/** Used to convert symbols to primitives and strings. */
|
|
|
var symbolProto = Symbol ? Symbol.prototype : undefined,
|
|
|
symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
|
|
|
|
|
|
/**
|
|
|
* Creates a clone of the `symbol` object.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} symbol The symbol object to clone.
|
|
|
* @returns {Object} Returns the cloned symbol object.
|
|
|
*/
|
|
|
function cloneSymbol(symbol) {
|
|
|
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
|
|
|
}
|
|
|
|
|
|
module.exports = cloneSymbol;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 143 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var copyObject = __webpack_require__(8),
|
|
|
getSymbols = __webpack_require__(33);
|
|
|
|
|
|
/**
|
|
|
* Copies own symbols of `source` to `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} source The object to copy symbols from.
|
|
|
* @param {Object} [object={}] The object to copy symbols to.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
function copySymbols(source, object) {
|
|
|
return copyObject(source, getSymbols(source), object);
|
|
|
}
|
|
|
|
|
|
module.exports = copySymbols;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 144 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var copyObject = __webpack_require__(8),
|
|
|
getSymbolsIn = __webpack_require__(60);
|
|
|
|
|
|
/**
|
|
|
* Copies own and inherited symbols of `source` to `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} source The object to copy symbols from.
|
|
|
* @param {Object} [object={}] The object to copy symbols to.
|
|
|
* @returns {Object} Returns `object`.
|
|
|
*/
|
|
|
function copySymbolsIn(source, object) {
|
|
|
return copyObject(source, getSymbolsIn(source), object);
|
|
|
}
|
|
|
|
|
|
module.exports = copySymbolsIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 145 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var root = __webpack_require__(1);
|
|
|
|
|
|
/** Used to detect overreaching core-js shims. */
|
|
|
var coreJsData = root['__core-js_shared__'];
|
|
|
|
|
|
module.exports = coreJsData;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 146 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseRest = __webpack_require__(130),
|
|
|
isIterateeCall = __webpack_require__(162);
|
|
|
|
|
|
/**
|
|
|
* Creates a function like `_.assign`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} assigner The function to assign values.
|
|
|
* @returns {Function} Returns the new assigner function.
|
|
|
*/
|
|
|
function createAssigner(assigner) {
|
|
|
return baseRest(function(object, sources) {
|
|
|
var index = -1,
|
|
|
length = sources.length,
|
|
|
customizer = length > 1 ? sources[length - 1] : undefined,
|
|
|
guard = length > 2 ? sources[2] : undefined;
|
|
|
|
|
|
customizer = (assigner.length > 3 && typeof customizer == 'function')
|
|
|
? (length--, customizer)
|
|
|
: undefined;
|
|
|
|
|
|
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
|
|
customizer = length < 3 ? undefined : customizer;
|
|
|
length = 1;
|
|
|
}
|
|
|
object = Object(object);
|
|
|
while (++index < length) {
|
|
|
var source = sources[index];
|
|
|
if (source) {
|
|
|
assigner(object, source, index, customizer);
|
|
|
}
|
|
|
}
|
|
|
return object;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
module.exports = createAssigner;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 147 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Creates a base function for methods like `_.forIn` and `_.forOwn`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {boolean} [fromRight] Specify iterating from right to left.
|
|
|
* @returns {Function} Returns the new base function.
|
|
|
*/
|
|
|
function createBaseFor(fromRight) {
|
|
|
return function(object, iteratee, keysFunc) {
|
|
|
var index = -1,
|
|
|
iterable = Object(object),
|
|
|
props = keysFunc(object),
|
|
|
length = props.length;
|
|
|
|
|
|
while (length--) {
|
|
|
var key = props[fromRight ? length : ++index];
|
|
|
if (iteratee(iterable[key], key, iterable) === false) {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return object;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = createBaseFor;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 148 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isPlainObject = __webpack_require__(67);
|
|
|
|
|
|
/**
|
|
|
* Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
|
|
|
* objects.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to inspect.
|
|
|
* @param {string} key The key of the property to inspect.
|
|
|
* @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
|
|
|
*/
|
|
|
function customOmitClone(value) {
|
|
|
return isPlainObject(value) ? undefined : value;
|
|
|
}
|
|
|
|
|
|
module.exports = customOmitClone;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 149 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGetAllKeys = __webpack_require__(52),
|
|
|
getSymbols = __webpack_require__(33),
|
|
|
keys = __webpack_require__(39);
|
|
|
|
|
|
/**
|
|
|
* Creates an array of own enumerable property names and symbols of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names and symbols.
|
|
|
*/
|
|
|
function getAllKeys(object) {
|
|
|
return baseGetAllKeys(object, keys, getSymbols);
|
|
|
}
|
|
|
|
|
|
module.exports = getAllKeys;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 150 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Symbol = __webpack_require__(12);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* Used to resolve the
|
|
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
|
|
* of values.
|
|
|
*/
|
|
|
var nativeObjectToString = objectProto.toString;
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to query.
|
|
|
* @returns {string} Returns the raw `toStringTag`.
|
|
|
*/
|
|
|
function getRawTag(value) {
|
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag),
|
|
|
tag = value[symToStringTag];
|
|
|
|
|
|
try {
|
|
|
value[symToStringTag] = undefined;
|
|
|
var unmasked = true;
|
|
|
} catch (e) {}
|
|
|
|
|
|
var result = nativeObjectToString.call(value);
|
|
|
if (unmasked) {
|
|
|
if (isOwn) {
|
|
|
value[symToStringTag] = tag;
|
|
|
} else {
|
|
|
delete value[symToStringTag];
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = getRawTag;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 151 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var DataView = __webpack_require__(103),
|
|
|
Map = __webpack_require__(27),
|
|
|
Promise = __webpack_require__(105),
|
|
|
Set = __webpack_require__(106),
|
|
|
WeakMap = __webpack_require__(108),
|
|
|
baseGetTag = __webpack_require__(6),
|
|
|
toSource = __webpack_require__(65);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var mapTag = '[object Map]',
|
|
|
objectTag = '[object Object]',
|
|
|
promiseTag = '[object Promise]',
|
|
|
setTag = '[object Set]',
|
|
|
weakMapTag = '[object WeakMap]';
|
|
|
|
|
|
var dataViewTag = '[object DataView]';
|
|
|
|
|
|
/** Used to detect maps, sets, and weakmaps. */
|
|
|
var dataViewCtorString = toSource(DataView),
|
|
|
mapCtorString = toSource(Map),
|
|
|
promiseCtorString = toSource(Promise),
|
|
|
setCtorString = toSource(Set),
|
|
|
weakMapCtorString = toSource(WeakMap);
|
|
|
|
|
|
/**
|
|
|
* Gets the `toStringTag` of `value`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to query.
|
|
|
* @returns {string} Returns the `toStringTag`.
|
|
|
*/
|
|
|
var getTag = baseGetTag;
|
|
|
|
|
|
// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
|
|
|
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
|
|
|
(Map && getTag(new Map) != mapTag) ||
|
|
|
(Promise && getTag(Promise.resolve()) != promiseTag) ||
|
|
|
(Set && getTag(new Set) != setTag) ||
|
|
|
(WeakMap && getTag(new WeakMap) != weakMapTag)) {
|
|
|
getTag = function(value) {
|
|
|
var result = baseGetTag(value),
|
|
|
Ctor = result == objectTag ? value.constructor : undefined,
|
|
|
ctorString = Ctor ? toSource(Ctor) : '';
|
|
|
|
|
|
if (ctorString) {
|
|
|
switch (ctorString) {
|
|
|
case dataViewCtorString: return dataViewTag;
|
|
|
case mapCtorString: return mapTag;
|
|
|
case promiseCtorString: return promiseTag;
|
|
|
case setCtorString: return setTag;
|
|
|
case weakMapCtorString: return weakMapTag;
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = getTag;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 152 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Gets the value at `key` of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} [object] The object to query.
|
|
|
* @param {string} key The key of the property to get.
|
|
|
* @returns {*} Returns the property value.
|
|
|
*/
|
|
|
function getValue(object, key) {
|
|
|
return object == null ? undefined : object[key];
|
|
|
}
|
|
|
|
|
|
module.exports = getValue;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 153 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var castPath = __webpack_require__(7),
|
|
|
isArguments = __webpack_require__(22),
|
|
|
isArray = __webpack_require__(2),
|
|
|
isIndex = __webpack_require__(18),
|
|
|
isLength = __webpack_require__(37),
|
|
|
toKey = __webpack_require__(20);
|
|
|
|
|
|
/**
|
|
|
* Checks if `path` exists on `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @param {Array|string} path The path to check.
|
|
|
* @param {Function} hasFunc The function to check properties.
|
|
|
* @returns {boolean} Returns `true` if `path` exists, else `false`.
|
|
|
*/
|
|
|
function hasPath(object, path, hasFunc) {
|
|
|
path = castPath(path, object);
|
|
|
|
|
|
var index = -1,
|
|
|
length = path.length,
|
|
|
result = false;
|
|
|
|
|
|
while (++index < length) {
|
|
|
var key = toKey(path[index]);
|
|
|
if (!(result = object != null && hasFunc(object, key))) {
|
|
|
break;
|
|
|
}
|
|
|
object = object[key];
|
|
|
}
|
|
|
if (result || ++index != length) {
|
|
|
return result;
|
|
|
}
|
|
|
length = object == null ? 0 : object.length;
|
|
|
return !!length && isLength(length) && isIndex(key, length) &&
|
|
|
(isArray(object) || isArguments(object));
|
|
|
}
|
|
|
|
|
|
module.exports = hasPath;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 154 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var nativeCreate = __webpack_require__(19);
|
|
|
|
|
|
/**
|
|
|
* Removes all key-value entries from the hash.
|
|
|
*
|
|
|
* @private
|
|
|
* @name clear
|
|
|
* @memberOf Hash
|
|
|
*/
|
|
|
function hashClear() {
|
|
|
this.__data__ = nativeCreate ? nativeCreate(null) : {};
|
|
|
this.size = 0;
|
|
|
}
|
|
|
|
|
|
module.exports = hashClear;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 155 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Removes `key` and its value from the hash.
|
|
|
*
|
|
|
* @private
|
|
|
* @name delete
|
|
|
* @memberOf Hash
|
|
|
* @param {Object} hash The hash to modify.
|
|
|
* @param {string} key The key of the value to remove.
|
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
|
|
*/
|
|
|
function hashDelete(key) {
|
|
|
var result = this.has(key) && delete this.__data__[key];
|
|
|
this.size -= result ? 1 : 0;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = hashDelete;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 156 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var nativeCreate = __webpack_require__(19);
|
|
|
|
|
|
/** Used to stand-in for `undefined` hash values. */
|
|
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* Gets the hash value for `key`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name get
|
|
|
* @memberOf Hash
|
|
|
* @param {string} key The key of the value to get.
|
|
|
* @returns {*} Returns the entry value.
|
|
|
*/
|
|
|
function hashGet(key) {
|
|
|
var data = this.__data__;
|
|
|
if (nativeCreate) {
|
|
|
var result = data[key];
|
|
|
return result === HASH_UNDEFINED ? undefined : result;
|
|
|
}
|
|
|
return hasOwnProperty.call(data, key) ? data[key] : undefined;
|
|
|
}
|
|
|
|
|
|
module.exports = hashGet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 157 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var nativeCreate = __webpack_require__(19);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* Checks if a hash value for `key` exists.
|
|
|
*
|
|
|
* @private
|
|
|
* @name has
|
|
|
* @memberOf Hash
|
|
|
* @param {string} key The key of the entry to check.
|
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
|
|
*/
|
|
|
function hashHas(key) {
|
|
|
var data = this.__data__;
|
|
|
return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
|
|
|
}
|
|
|
|
|
|
module.exports = hashHas;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 158 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var nativeCreate = __webpack_require__(19);
|
|
|
|
|
|
/** Used to stand-in for `undefined` hash values. */
|
|
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
|
|
|
|
|
/**
|
|
|
* Sets the hash `key` to `value`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name set
|
|
|
* @memberOf Hash
|
|
|
* @param {string} key The key of the value to set.
|
|
|
* @param {*} value The value to set.
|
|
|
* @returns {Object} Returns the hash instance.
|
|
|
*/
|
|
|
function hashSet(key, value) {
|
|
|
var data = this.__data__;
|
|
|
this.size += this.has(key) ? 0 : 1;
|
|
|
data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
module.exports = hashSet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 159 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/** Used to check objects for own properties. */
|
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
|
|
/**
|
|
|
* Initializes an array clone.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Array} array The array to clone.
|
|
|
* @returns {Array} Returns the initialized clone.
|
|
|
*/
|
|
|
function initCloneArray(array) {
|
|
|
var length = array.length,
|
|
|
result = array.constructor(length);
|
|
|
|
|
|
// Add properties assigned by `RegExp#exec`.
|
|
|
if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
|
|
|
result.index = array.index;
|
|
|
result.input = array.input;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = initCloneArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 160 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var cloneArrayBuffer = __webpack_require__(31),
|
|
|
cloneDataView = __webpack_require__(138),
|
|
|
cloneMap = __webpack_require__(139),
|
|
|
cloneRegExp = __webpack_require__(140),
|
|
|
cloneSet = __webpack_require__(141),
|
|
|
cloneSymbol = __webpack_require__(142),
|
|
|
cloneTypedArray = __webpack_require__(54);
|
|
|
|
|
|
/** `Object#toString` result references. */
|
|
|
var boolTag = '[object Boolean]',
|
|
|
dateTag = '[object Date]',
|
|
|
mapTag = '[object Map]',
|
|
|
numberTag = '[object Number]',
|
|
|
regexpTag = '[object RegExp]',
|
|
|
setTag = '[object Set]',
|
|
|
stringTag = '[object String]',
|
|
|
symbolTag = '[object Symbol]';
|
|
|
|
|
|
var arrayBufferTag = '[object ArrayBuffer]',
|
|
|
dataViewTag = '[object DataView]',
|
|
|
float32Tag = '[object Float32Array]',
|
|
|
float64Tag = '[object Float64Array]',
|
|
|
int8Tag = '[object Int8Array]',
|
|
|
int16Tag = '[object Int16Array]',
|
|
|
int32Tag = '[object Int32Array]',
|
|
|
uint8Tag = '[object Uint8Array]',
|
|
|
uint8ClampedTag = '[object Uint8ClampedArray]',
|
|
|
uint16Tag = '[object Uint16Array]',
|
|
|
uint32Tag = '[object Uint32Array]';
|
|
|
|
|
|
/**
|
|
|
* Initializes an object clone based on its `toStringTag`.
|
|
|
*
|
|
|
* **Note:** This function only supports cloning values with tags of
|
|
|
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to clone.
|
|
|
* @param {string} tag The `toStringTag` of the object to clone.
|
|
|
* @param {Function} cloneFunc The function to clone values.
|
|
|
* @param {boolean} [isDeep] Specify a deep clone.
|
|
|
* @returns {Object} Returns the initialized clone.
|
|
|
*/
|
|
|
function initCloneByTag(object, tag, cloneFunc, isDeep) {
|
|
|
var Ctor = object.constructor;
|
|
|
switch (tag) {
|
|
|
case arrayBufferTag:
|
|
|
return cloneArrayBuffer(object);
|
|
|
|
|
|
case boolTag:
|
|
|
case dateTag:
|
|
|
return new Ctor(+object);
|
|
|
|
|
|
case dataViewTag:
|
|
|
return cloneDataView(object, isDeep);
|
|
|
|
|
|
case float32Tag: case float64Tag:
|
|
|
case int8Tag: case int16Tag: case int32Tag:
|
|
|
case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
|
|
|
return cloneTypedArray(object, isDeep);
|
|
|
|
|
|
case mapTag:
|
|
|
return cloneMap(object, isDeep, cloneFunc);
|
|
|
|
|
|
case numberTag:
|
|
|
case stringTag:
|
|
|
return new Ctor(object);
|
|
|
|
|
|
case regexpTag:
|
|
|
return cloneRegExp(object);
|
|
|
|
|
|
case setTag:
|
|
|
return cloneSet(object, isDeep, cloneFunc);
|
|
|
|
|
|
case symbolTag:
|
|
|
return cloneSymbol(object);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
module.exports = initCloneByTag;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 161 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Symbol = __webpack_require__(12),
|
|
|
isArguments = __webpack_require__(22),
|
|
|
isArray = __webpack_require__(2);
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is a flattenable `arguments` object or array.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
|
|
|
*/
|
|
|
function isFlattenable(value) {
|
|
|
return isArray(value) || isArguments(value) ||
|
|
|
!!(spreadableSymbol && value && value[spreadableSymbol]);
|
|
|
}
|
|
|
|
|
|
module.exports = isFlattenable;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 162 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var eq = __webpack_require__(21),
|
|
|
isArrayLike = __webpack_require__(23),
|
|
|
isIndex = __webpack_require__(18),
|
|
|
isObject = __webpack_require__(3);
|
|
|
|
|
|
/**
|
|
|
* Checks if the given arguments are from an iteratee call.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The potential iteratee value argument.
|
|
|
* @param {*} index The potential iteratee index or key argument.
|
|
|
* @param {*} object The potential iteratee object argument.
|
|
|
* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
|
|
|
* else `false`.
|
|
|
*/
|
|
|
function isIterateeCall(value, index, object) {
|
|
|
if (!isObject(object)) {
|
|
|
return false;
|
|
|
}
|
|
|
var type = typeof index;
|
|
|
if (type == 'number'
|
|
|
? (isArrayLike(object) && isIndex(index, object.length))
|
|
|
: (type == 'string' && index in object)
|
|
|
) {
|
|
|
return eq(object[index], value);
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
module.exports = isIterateeCall;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 163 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isArray = __webpack_require__(2),
|
|
|
isSymbol = __webpack_require__(38);
|
|
|
|
|
|
/** Used to match property names within property paths. */
|
|
|
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
|
|
|
reIsPlainProp = /^\w*$/;
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is a property name and not a property path.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @param {Object} [object] The object to query keys on.
|
|
|
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
|
|
|
*/
|
|
|
function isKey(value, object) {
|
|
|
if (isArray(value)) {
|
|
|
return false;
|
|
|
}
|
|
|
var type = typeof value;
|
|
|
if (type == 'number' || type == 'symbol' || type == 'boolean' ||
|
|
|
value == null || isSymbol(value)) {
|
|
|
return true;
|
|
|
}
|
|
|
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
|
|
|
(object != null && value in Object(object));
|
|
|
}
|
|
|
|
|
|
module.exports = isKey;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 164 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Checks if `value` is suitable for use as unique object key.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
|
|
|
*/
|
|
|
function isKeyable(value) {
|
|
|
var type = typeof value;
|
|
|
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
|
|
|
? (value !== '__proto__')
|
|
|
: (value === null);
|
|
|
}
|
|
|
|
|
|
module.exports = isKeyable;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 165 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var coreJsData = __webpack_require__(145);
|
|
|
|
|
|
/** Used to detect methods masquerading as native. */
|
|
|
var maskSrcKey = (function() {
|
|
|
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
|
|
|
return uid ? ('Symbol(src)_1.' + uid) : '';
|
|
|
}());
|
|
|
|
|
|
/**
|
|
|
* Checks if `func` has its source masked.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to check.
|
|
|
* @returns {boolean} Returns `true` if `func` is masked, else `false`.
|
|
|
*/
|
|
|
function isMasked(func) {
|
|
|
return !!maskSrcKey && (maskSrcKey in func);
|
|
|
}
|
|
|
|
|
|
module.exports = isMasked;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 166 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Removes all key-value entries from the list cache.
|
|
|
*
|
|
|
* @private
|
|
|
* @name clear
|
|
|
* @memberOf ListCache
|
|
|
*/
|
|
|
function listCacheClear() {
|
|
|
this.__data__ = [];
|
|
|
this.size = 0;
|
|
|
}
|
|
|
|
|
|
module.exports = listCacheClear;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 167 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assocIndexOf = __webpack_require__(16);
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var arrayProto = Array.prototype;
|
|
|
|
|
|
/** Built-in value references. */
|
|
|
var splice = arrayProto.splice;
|
|
|
|
|
|
/**
|
|
|
* Removes `key` and its value from the list cache.
|
|
|
*
|
|
|
* @private
|
|
|
* @name delete
|
|
|
* @memberOf ListCache
|
|
|
* @param {string} key The key of the value to remove.
|
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
|
|
*/
|
|
|
function listCacheDelete(key) {
|
|
|
var data = this.__data__,
|
|
|
index = assocIndexOf(data, key);
|
|
|
|
|
|
if (index < 0) {
|
|
|
return false;
|
|
|
}
|
|
|
var lastIndex = data.length - 1;
|
|
|
if (index == lastIndex) {
|
|
|
data.pop();
|
|
|
} else {
|
|
|
splice.call(data, index, 1);
|
|
|
}
|
|
|
--this.size;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
module.exports = listCacheDelete;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 168 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assocIndexOf = __webpack_require__(16);
|
|
|
|
|
|
/**
|
|
|
* Gets the list cache value for `key`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name get
|
|
|
* @memberOf ListCache
|
|
|
* @param {string} key The key of the value to get.
|
|
|
* @returns {*} Returns the entry value.
|
|
|
*/
|
|
|
function listCacheGet(key) {
|
|
|
var data = this.__data__,
|
|
|
index = assocIndexOf(data, key);
|
|
|
|
|
|
return index < 0 ? undefined : data[index][1];
|
|
|
}
|
|
|
|
|
|
module.exports = listCacheGet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 169 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assocIndexOf = __webpack_require__(16);
|
|
|
|
|
|
/**
|
|
|
* Checks if a list cache value for `key` exists.
|
|
|
*
|
|
|
* @private
|
|
|
* @name has
|
|
|
* @memberOf ListCache
|
|
|
* @param {string} key The key of the entry to check.
|
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
|
|
*/
|
|
|
function listCacheHas(key) {
|
|
|
return assocIndexOf(this.__data__, key) > -1;
|
|
|
}
|
|
|
|
|
|
module.exports = listCacheHas;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 170 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var assocIndexOf = __webpack_require__(16);
|
|
|
|
|
|
/**
|
|
|
* Sets the list cache `key` to `value`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name set
|
|
|
* @memberOf ListCache
|
|
|
* @param {string} key The key of the value to set.
|
|
|
* @param {*} value The value to set.
|
|
|
* @returns {Object} Returns the list cache instance.
|
|
|
*/
|
|
|
function listCacheSet(key, value) {
|
|
|
var data = this.__data__,
|
|
|
index = assocIndexOf(data, key);
|
|
|
|
|
|
if (index < 0) {
|
|
|
++this.size;
|
|
|
data.push([key, value]);
|
|
|
} else {
|
|
|
data[index][1] = value;
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
module.exports = listCacheSet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 171 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var Hash = __webpack_require__(104),
|
|
|
ListCache = __webpack_require__(15),
|
|
|
Map = __webpack_require__(27);
|
|
|
|
|
|
/**
|
|
|
* Removes all key-value entries from the map.
|
|
|
*
|
|
|
* @private
|
|
|
* @name clear
|
|
|
* @memberOf MapCache
|
|
|
*/
|
|
|
function mapCacheClear() {
|
|
|
this.size = 0;
|
|
|
this.__data__ = {
|
|
|
'hash': new Hash,
|
|
|
'map': new (Map || ListCache),
|
|
|
'string': new Hash
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = mapCacheClear;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 172 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getMapData = __webpack_require__(17);
|
|
|
|
|
|
/**
|
|
|
* Removes `key` and its value from the map.
|
|
|
*
|
|
|
* @private
|
|
|
* @name delete
|
|
|
* @memberOf MapCache
|
|
|
* @param {string} key The key of the value to remove.
|
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
|
|
*/
|
|
|
function mapCacheDelete(key) {
|
|
|
var result = getMapData(this, key)['delete'](key);
|
|
|
this.size -= result ? 1 : 0;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = mapCacheDelete;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 173 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getMapData = __webpack_require__(17);
|
|
|
|
|
|
/**
|
|
|
* Gets the map value for `key`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name get
|
|
|
* @memberOf MapCache
|
|
|
* @param {string} key The key of the value to get.
|
|
|
* @returns {*} Returns the entry value.
|
|
|
*/
|
|
|
function mapCacheGet(key) {
|
|
|
return getMapData(this, key).get(key);
|
|
|
}
|
|
|
|
|
|
module.exports = mapCacheGet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 174 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getMapData = __webpack_require__(17);
|
|
|
|
|
|
/**
|
|
|
* Checks if a map value for `key` exists.
|
|
|
*
|
|
|
* @private
|
|
|
* @name has
|
|
|
* @memberOf MapCache
|
|
|
* @param {string} key The key of the entry to check.
|
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
|
|
*/
|
|
|
function mapCacheHas(key) {
|
|
|
return getMapData(this, key).has(key);
|
|
|
}
|
|
|
|
|
|
module.exports = mapCacheHas;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 175 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var getMapData = __webpack_require__(17);
|
|
|
|
|
|
/**
|
|
|
* Sets the map `key` to `value`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name set
|
|
|
* @memberOf MapCache
|
|
|
* @param {string} key The key of the value to set.
|
|
|
* @param {*} value The value to set.
|
|
|
* @returns {Object} Returns the map cache instance.
|
|
|
*/
|
|
|
function mapCacheSet(key, value) {
|
|
|
var data = getMapData(this, key),
|
|
|
size = data.size;
|
|
|
|
|
|
data.set(key, value);
|
|
|
this.size += data.size == size ? 0 : 1;
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
module.exports = mapCacheSet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 176 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Converts `map` to its key-value pairs.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} map The map to convert.
|
|
|
* @returns {Array} Returns the key-value pairs.
|
|
|
*/
|
|
|
function mapToArray(map) {
|
|
|
var index = -1,
|
|
|
result = Array(map.size);
|
|
|
|
|
|
map.forEach(function(value, key) {
|
|
|
result[++index] = [key, value];
|
|
|
});
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = mapToArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 177 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var memoize = __webpack_require__(196);
|
|
|
|
|
|
/** Used as the maximum memoize cache size. */
|
|
|
var MAX_MEMOIZE_SIZE = 500;
|
|
|
|
|
|
/**
|
|
|
* A specialized version of `_.memoize` which clears the memoized function's
|
|
|
* cache when it exceeds `MAX_MEMOIZE_SIZE`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to have its output memoized.
|
|
|
* @returns {Function} Returns the new memoized function.
|
|
|
*/
|
|
|
function memoizeCapped(func) {
|
|
|
var result = memoize(func, function(key) {
|
|
|
if (cache.size === MAX_MEMOIZE_SIZE) {
|
|
|
cache.clear();
|
|
|
}
|
|
|
return key;
|
|
|
});
|
|
|
|
|
|
var cache = result.cache;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = memoizeCapped;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 178 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var overArg = __webpack_require__(62);
|
|
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
|
var nativeKeys = overArg(Object.keys, Object);
|
|
|
|
|
|
module.exports = nativeKeys;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 179 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* This function is like
|
|
|
* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
|
|
|
* except that it includes inherited enumerable properties.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @returns {Array} Returns the array of property names.
|
|
|
*/
|
|
|
function nativeKeysIn(object) {
|
|
|
var result = [];
|
|
|
if (object != null) {
|
|
|
for (var key in Object(object)) {
|
|
|
result.push(key);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = nativeKeysIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 180 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__(58);
|
|
|
|
|
|
/** Detect free variable `exports`. */
|
|
|
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
|
|
|
|
|
|
/** Detect free variable `module`. */
|
|
|
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
|
|
|
|
|
|
/** Detect the popular CommonJS extension `module.exports`. */
|
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
|
|
|
|
/** Detect free variable `process` from Node.js. */
|
|
|
var freeProcess = moduleExports && freeGlobal.process;
|
|
|
|
|
|
/** Used to access faster Node.js helpers. */
|
|
|
var nodeUtil = (function() {
|
|
|
try {
|
|
|
return freeProcess && freeProcess.binding && freeProcess.binding('util');
|
|
|
} catch (e) {}
|
|
|
}());
|
|
|
|
|
|
module.exports = nodeUtil;
|
|
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(41)(module)))
|
|
|
|
|
|
/***/ }),
|
|
|
/* 181 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used for built-in method references. */
|
|
|
var objectProto = Object.prototype;
|
|
|
|
|
|
/**
|
|
|
* Used to resolve the
|
|
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
|
|
* of values.
|
|
|
*/
|
|
|
var nativeObjectToString = objectProto.toString;
|
|
|
|
|
|
/**
|
|
|
* Converts `value` to a string using `Object.prototype.toString`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {*} value The value to convert.
|
|
|
* @returns {string} Returns the converted string.
|
|
|
*/
|
|
|
function objectToString(value) {
|
|
|
return nativeObjectToString.call(value);
|
|
|
}
|
|
|
|
|
|
module.exports = objectToString;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 182 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseGet = __webpack_require__(51),
|
|
|
baseSlice = __webpack_require__(133);
|
|
|
|
|
|
/**
|
|
|
* Gets the parent value at `path` of `object`.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} object The object to query.
|
|
|
* @param {Array} path The path to get the parent value of.
|
|
|
* @returns {*} Returns the parent value.
|
|
|
*/
|
|
|
function parent(object, path) {
|
|
|
return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
|
|
|
}
|
|
|
|
|
|
module.exports = parent;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 183 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Converts `set` to an array of its values.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Object} set The set to convert.
|
|
|
* @returns {Array} Returns the values.
|
|
|
*/
|
|
|
function setToArray(set) {
|
|
|
var index = -1,
|
|
|
result = Array(set.size);
|
|
|
|
|
|
set.forEach(function(value) {
|
|
|
result[++index] = value;
|
|
|
});
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = setToArray;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 184 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/** Used to detect hot functions by number of calls within a span of milliseconds. */
|
|
|
var HOT_COUNT = 800,
|
|
|
HOT_SPAN = 16;
|
|
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
|
var nativeNow = Date.now;
|
|
|
|
|
|
/**
|
|
|
* Creates a function that'll short out and invoke `identity` instead
|
|
|
* of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
|
|
|
* milliseconds.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {Function} func The function to restrict.
|
|
|
* @returns {Function} Returns the new shortable function.
|
|
|
*/
|
|
|
function shortOut(func) {
|
|
|
var count = 0,
|
|
|
lastCalled = 0;
|
|
|
|
|
|
return function() {
|
|
|
var stamp = nativeNow(),
|
|
|
remaining = HOT_SPAN - (stamp - lastCalled);
|
|
|
|
|
|
lastCalled = stamp;
|
|
|
if (remaining > 0) {
|
|
|
if (++count >= HOT_COUNT) {
|
|
|
return arguments[0];
|
|
|
}
|
|
|
} else {
|
|
|
count = 0;
|
|
|
}
|
|
|
return func.apply(undefined, arguments);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = shortOut;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 185 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var ListCache = __webpack_require__(15);
|
|
|
|
|
|
/**
|
|
|
* Removes all key-value entries from the stack.
|
|
|
*
|
|
|
* @private
|
|
|
* @name clear
|
|
|
* @memberOf Stack
|
|
|
*/
|
|
|
function stackClear() {
|
|
|
this.__data__ = new ListCache;
|
|
|
this.size = 0;
|
|
|
}
|
|
|
|
|
|
module.exports = stackClear;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 186 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Removes `key` and its value from the stack.
|
|
|
*
|
|
|
* @private
|
|
|
* @name delete
|
|
|
* @memberOf Stack
|
|
|
* @param {string} key The key of the value to remove.
|
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
|
|
*/
|
|
|
function stackDelete(key) {
|
|
|
var data = this.__data__,
|
|
|
result = data['delete'](key);
|
|
|
|
|
|
this.size = data.size;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
module.exports = stackDelete;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 187 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Gets the stack value for `key`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name get
|
|
|
* @memberOf Stack
|
|
|
* @param {string} key The key of the value to get.
|
|
|
* @returns {*} Returns the entry value.
|
|
|
*/
|
|
|
function stackGet(key) {
|
|
|
return this.__data__.get(key);
|
|
|
}
|
|
|
|
|
|
module.exports = stackGet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 188 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Checks if a stack value for `key` exists.
|
|
|
*
|
|
|
* @private
|
|
|
* @name has
|
|
|
* @memberOf Stack
|
|
|
* @param {string} key The key of the entry to check.
|
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
|
|
*/
|
|
|
function stackHas(key) {
|
|
|
return this.__data__.has(key);
|
|
|
}
|
|
|
|
|
|
module.exports = stackHas;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 189 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var ListCache = __webpack_require__(15),
|
|
|
Map = __webpack_require__(27),
|
|
|
MapCache = __webpack_require__(45);
|
|
|
|
|
|
/** Used as the size to enable large array optimizations. */
|
|
|
var LARGE_ARRAY_SIZE = 200;
|
|
|
|
|
|
/**
|
|
|
* Sets the stack `key` to `value`.
|
|
|
*
|
|
|
* @private
|
|
|
* @name set
|
|
|
* @memberOf Stack
|
|
|
* @param {string} key The key of the value to set.
|
|
|
* @param {*} value The value to set.
|
|
|
* @returns {Object} Returns the stack cache instance.
|
|
|
*/
|
|
|
function stackSet(key, value) {
|
|
|
var data = this.__data__;
|
|
|
if (data instanceof ListCache) {
|
|
|
var pairs = data.__data__;
|
|
|
if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
|
|
|
pairs.push([key, value]);
|
|
|
this.size = ++data.size;
|
|
|
return this;
|
|
|
}
|
|
|
data = this.__data__ = new MapCache(pairs);
|
|
|
}
|
|
|
data.set(key, value);
|
|
|
this.size = data.size;
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
module.exports = stackSet;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 190 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var memoizeCapped = __webpack_require__(177);
|
|
|
|
|
|
/** Used to match property names within property paths. */
|
|
|
var reLeadingDot = /^\./,
|
|
|
rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
|
|
|
|
|
|
/** Used to match backslashes in property paths. */
|
|
|
var reEscapeChar = /\\(\\)?/g;
|
|
|
|
|
|
/**
|
|
|
* Converts `string` to a property path array.
|
|
|
*
|
|
|
* @private
|
|
|
* @param {string} string The string to convert.
|
|
|
* @returns {Array} Returns the property path array.
|
|
|
*/
|
|
|
var stringToPath = memoizeCapped(function(string) {
|
|
|
var result = [];
|
|
|
if (reLeadingDot.test(string)) {
|
|
|
result.push('');
|
|
|
}
|
|
|
string.replace(rePropName, function(match, number, quote, string) {
|
|
|
result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
|
|
|
});
|
|
|
return result;
|
|
|
});
|
|
|
|
|
|
module.exports = stringToPath;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 191 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Creates a function that returns `value`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 2.4.0
|
|
|
* @category Util
|
|
|
* @param {*} value The value to return from the new function.
|
|
|
* @returns {Function} Returns the new constant function.
|
|
|
* @example
|
|
|
*
|
|
|
* var objects = _.times(2, _.constant({ 'a': 1 }));
|
|
|
*
|
|
|
* console.log(objects);
|
|
|
* // => [{ 'a': 1 }, { 'a': 1 }]
|
|
|
*
|
|
|
* console.log(objects[0] === objects[1]);
|
|
|
* // => true
|
|
|
*/
|
|
|
function constant(value) {
|
|
|
return function() {
|
|
|
return value;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
module.exports = constant;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 192 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseFlatten = __webpack_require__(118);
|
|
|
|
|
|
/**
|
|
|
* Flattens `array` a single level deep.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Array
|
|
|
* @param {Array} array The array to flatten.
|
|
|
* @returns {Array} Returns the new flattened array.
|
|
|
* @example
|
|
|
*
|
|
|
* _.flatten([1, [2, [3, [4]], 5]]);
|
|
|
* // => [1, 2, [3, [4]], 5]
|
|
|
*/
|
|
|
function flatten(array) {
|
|
|
var length = array == null ? 0 : array.length;
|
|
|
return length ? baseFlatten(array, 1) : [];
|
|
|
}
|
|
|
|
|
|
module.exports = flatten;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 193 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseHasIn = __webpack_require__(120),
|
|
|
hasPath = __webpack_require__(153);
|
|
|
|
|
|
/**
|
|
|
* Checks if `path` is a direct or inherited property of `object`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Object
|
|
|
* @param {Object} object The object to query.
|
|
|
* @param {Array|string} path The path to check.
|
|
|
* @returns {boolean} Returns `true` if `path` exists, else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = _.create({ 'a': _.create({ 'b': 2 }) });
|
|
|
*
|
|
|
* _.hasIn(object, 'a');
|
|
|
* // => true
|
|
|
*
|
|
|
* _.hasIn(object, 'a.b');
|
|
|
* // => true
|
|
|
*
|
|
|
* _.hasIn(object, ['a', 'b']);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.hasIn(object, 'b');
|
|
|
* // => false
|
|
|
*/
|
|
|
function hasIn(object, path) {
|
|
|
return object != null && hasPath(object, path, baseHasIn);
|
|
|
}
|
|
|
|
|
|
module.exports = hasIn;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 194 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var isArrayLike = __webpack_require__(23),
|
|
|
isObjectLike = __webpack_require__(9);
|
|
|
|
|
|
/**
|
|
|
* This method is like `_.isArrayLike` except that it also checks if `value`
|
|
|
* is an object.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to check.
|
|
|
* @returns {boolean} Returns `true` if `value` is an array-like object,
|
|
|
* else `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.isArrayLikeObject([1, 2, 3]);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArrayLikeObject(document.body.children);
|
|
|
* // => true
|
|
|
*
|
|
|
* _.isArrayLikeObject('abc');
|
|
|
* // => false
|
|
|
*
|
|
|
* _.isArrayLikeObject(_.noop);
|
|
|
* // => false
|
|
|
*/
|
|
|
function isArrayLikeObject(value) {
|
|
|
return isObjectLike(value) && isArrayLike(value);
|
|
|
}
|
|
|
|
|
|
module.exports = isArrayLikeObject;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 195 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* Gets the last element of `array`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Array
|
|
|
* @param {Array} array The array to query.
|
|
|
* @returns {*} Returns the last element of `array`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.last([1, 2, 3]);
|
|
|
* // => 3
|
|
|
*/
|
|
|
function last(array) {
|
|
|
var length = array == null ? 0 : array.length;
|
|
|
return length ? array[length - 1] : undefined;
|
|
|
}
|
|
|
|
|
|
module.exports = last;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 196 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var MapCache = __webpack_require__(45);
|
|
|
|
|
|
/** Error message constants. */
|
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
|
|
/**
|
|
|
* Creates a function that memoizes the result of `func`. If `resolver` is
|
|
|
* provided, it determines the cache key for storing the result based on the
|
|
|
* arguments provided to the memoized function. By default, the first argument
|
|
|
* provided to the memoized function is used as the map cache key. The `func`
|
|
|
* is invoked with the `this` binding of the memoized function.
|
|
|
*
|
|
|
* **Note:** The cache is exposed as the `cache` property on the memoized
|
|
|
* function. Its creation may be customized by replacing the `_.memoize.Cache`
|
|
|
* constructor with one whose instances implement the
|
|
|
* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
|
|
|
* method interface of `clear`, `delete`, `get`, `has`, and `set`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 0.1.0
|
|
|
* @category Function
|
|
|
* @param {Function} func The function to have its output memoized.
|
|
|
* @param {Function} [resolver] The function to resolve the cache key.
|
|
|
* @returns {Function} Returns the new memoized function.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = { 'a': 1, 'b': 2 };
|
|
|
* var other = { 'c': 3, 'd': 4 };
|
|
|
*
|
|
|
* var values = _.memoize(_.values);
|
|
|
* values(object);
|
|
|
* // => [1, 2]
|
|
|
*
|
|
|
* values(other);
|
|
|
* // => [3, 4]
|
|
|
*
|
|
|
* object.a = 2;
|
|
|
* values(object);
|
|
|
* // => [1, 2]
|
|
|
*
|
|
|
* // Modify the result cache.
|
|
|
* values.cache.set(object, ['a', 'b']);
|
|
|
* values(object);
|
|
|
* // => ['a', 'b']
|
|
|
*
|
|
|
* // Replace `_.memoize.Cache`.
|
|
|
* _.memoize.Cache = WeakMap;
|
|
|
*/
|
|
|
function memoize(func, resolver) {
|
|
|
if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
|
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
|
}
|
|
|
var memoized = function() {
|
|
|
var args = arguments,
|
|
|
key = resolver ? resolver.apply(this, args) : args[0],
|
|
|
cache = memoized.cache;
|
|
|
|
|
|
if (cache.has(key)) {
|
|
|
return cache.get(key);
|
|
|
}
|
|
|
var result = func.apply(this, args);
|
|
|
memoized.cache = cache.set(key, result) || cache;
|
|
|
return result;
|
|
|
};
|
|
|
memoized.cache = new (memoize.Cache || MapCache);
|
|
|
return memoized;
|
|
|
}
|
|
|
|
|
|
// Expose `MapCache`.
|
|
|
memoize.Cache = MapCache;
|
|
|
|
|
|
module.exports = memoize;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 197 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var arrayMap = __webpack_require__(48),
|
|
|
baseClone = __webpack_require__(116),
|
|
|
baseUnset = __webpack_require__(137),
|
|
|
castPath = __webpack_require__(7),
|
|
|
copyObject = __webpack_require__(8),
|
|
|
customOmitClone = __webpack_require__(148),
|
|
|
flatRest = __webpack_require__(57),
|
|
|
getAllKeysIn = __webpack_require__(59);
|
|
|
|
|
|
/** Used to compose bitmasks for cloning. */
|
|
|
var CLONE_DEEP_FLAG = 1,
|
|
|
CLONE_FLAT_FLAG = 2,
|
|
|
CLONE_SYMBOLS_FLAG = 4;
|
|
|
|
|
|
/**
|
|
|
* The opposite of `_.pick`; this method creates an object composed of the
|
|
|
* own and inherited enumerable property paths of `object` that are not omitted.
|
|
|
*
|
|
|
* **Note:** This method is considerably slower than `_.pick`.
|
|
|
*
|
|
|
* @static
|
|
|
* @since 0.1.0
|
|
|
* @memberOf _
|
|
|
* @category Object
|
|
|
* @param {Object} object The source object.
|
|
|
* @param {...(string|string[])} [paths] The property paths to omit.
|
|
|
* @returns {Object} Returns the new object.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = { 'a': 1, 'b': '2', 'c': 3 };
|
|
|
*
|
|
|
* _.omit(object, ['a', 'c']);
|
|
|
* // => { 'b': '2' }
|
|
|
*/
|
|
|
var omit = flatRest(function(object, paths) {
|
|
|
var result = {};
|
|
|
if (object == null) {
|
|
|
return result;
|
|
|
}
|
|
|
var isDeep = false;
|
|
|
paths = arrayMap(paths, function(path) {
|
|
|
path = castPath(path, object);
|
|
|
isDeep || (isDeep = path.length > 1);
|
|
|
return path;
|
|
|
});
|
|
|
copyObject(object, getAllKeysIn(object), result);
|
|
|
if (isDeep) {
|
|
|
result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
|
|
|
}
|
|
|
var length = paths.length;
|
|
|
while (length--) {
|
|
|
baseUnset(result, paths[length]);
|
|
|
}
|
|
|
return result;
|
|
|
});
|
|
|
|
|
|
module.exports = omit;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 198 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var basePick = __webpack_require__(128),
|
|
|
flatRest = __webpack_require__(57);
|
|
|
|
|
|
/**
|
|
|
* Creates an object composed of the picked `object` properties.
|
|
|
*
|
|
|
* @static
|
|
|
* @since 0.1.0
|
|
|
* @memberOf _
|
|
|
* @category Object
|
|
|
* @param {Object} object The source object.
|
|
|
* @param {...(string|string[])} [paths] The property paths to pick.
|
|
|
* @returns {Object} Returns the new object.
|
|
|
* @example
|
|
|
*
|
|
|
* var object = { 'a': 1, 'b': '2', 'c': 3 };
|
|
|
*
|
|
|
* _.pick(object, ['a', 'c']);
|
|
|
* // => { 'a': 1, 'c': 3 }
|
|
|
*/
|
|
|
var pick = flatRest(function(object, paths) {
|
|
|
return object == null ? {} : basePick(object, paths);
|
|
|
});
|
|
|
|
|
|
module.exports = pick;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 199 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
|
* This method returns `false`.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.13.0
|
|
|
* @category Util
|
|
|
* @returns {boolean} Returns `false`.
|
|
|
* @example
|
|
|
*
|
|
|
* _.times(2, _.stubFalse);
|
|
|
* // => [false, false]
|
|
|
*/
|
|
|
function stubFalse() {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
module.exports = stubFalse;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 200 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var copyObject = __webpack_require__(8),
|
|
|
keysIn = __webpack_require__(24);
|
|
|
|
|
|
/**
|
|
|
* Converts `value` to a plain object flattening inherited enumerable string
|
|
|
* keyed properties of `value` to own properties of the plain object.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 3.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to convert.
|
|
|
* @returns {Object} Returns the converted plain object.
|
|
|
* @example
|
|
|
*
|
|
|
* function Foo() {
|
|
|
* this.b = 2;
|
|
|
* }
|
|
|
*
|
|
|
* Foo.prototype.c = 3;
|
|
|
*
|
|
|
* _.assign({ 'a': 1 }, new Foo);
|
|
|
* // => { 'a': 1, 'b': 2 }
|
|
|
*
|
|
|
* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
|
|
|
* // => { 'a': 1, 'b': 2, 'c': 3 }
|
|
|
*/
|
|
|
function toPlainObject(value) {
|
|
|
return copyObject(value, keysIn(value));
|
|
|
}
|
|
|
|
|
|
module.exports = toPlainObject;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 201 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var baseToString = __webpack_require__(135);
|
|
|
|
|
|
/**
|
|
|
* Converts `value` to a string. An empty string is returned for `null`
|
|
|
* and `undefined` values. The sign of `-0` is preserved.
|
|
|
*
|
|
|
* @static
|
|
|
* @memberOf _
|
|
|
* @since 4.0.0
|
|
|
* @category Lang
|
|
|
* @param {*} value The value to convert.
|
|
|
* @returns {string} Returns the converted string.
|
|
|
* @example
|
|
|
*
|
|
|
* _.toString(null);
|
|
|
* // => ''
|
|
|
*
|
|
|
* _.toString(-0);
|
|
|
* // => '-0'
|
|
|
*
|
|
|
* _.toString([1, 2, 3]);
|
|
|
* // => '1,2,3'
|
|
|
*/
|
|
|
function toString(value) {
|
|
|
return value == null ? '' : baseToString(value);
|
|
|
}
|
|
|
|
|
|
module.exports = toString;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 202 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
// SDP helpers.
|
|
|
var SDPUtils = {};
|
|
|
|
|
|
// Generate an alphanumeric identifier for cname or mids.
|
|
|
// TODO: use UUIDs instead? https://gist.github.com/jed/982883
|
|
|
SDPUtils.generateIdentifier = function() {
|
|
|
return Math.random().toString(36).substr(2, 10);
|
|
|
};
|
|
|
|
|
|
// The RTCP CNAME used by all peerconnections from the same JS.
|
|
|
SDPUtils.localCName = SDPUtils.generateIdentifier();
|
|
|
|
|
|
// Splits SDP into lines, dealing with both CRLF and LF.
|
|
|
SDPUtils.splitLines = function(blob) {
|
|
|
return blob.trim().split('\n').map(function(line) {
|
|
|
return line.trim();
|
|
|
});
|
|
|
};
|
|
|
// Splits SDP into sessionpart and mediasections. Ensures CRLF.
|
|
|
SDPUtils.splitSections = function(blob) {
|
|
|
var parts = blob.split('\nm=');
|
|
|
return parts.map(function(part, index) {
|
|
|
return (index > 0 ? 'm=' + part : part).trim() + '\r\n';
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// Returns lines that start with a certain prefix.
|
|
|
SDPUtils.matchPrefix = function(blob, prefix) {
|
|
|
return SDPUtils.splitLines(blob).filter(function(line) {
|
|
|
return line.indexOf(prefix) === 0;
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// Parses an ICE candidate line. Sample input:
|
|
|
// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8
|
|
|
// rport 55996"
|
|
|
SDPUtils.parseCandidate = function(line) {
|
|
|
var parts;
|
|
|
// Parse both variants.
|
|
|
if (line.indexOf('a=candidate:') === 0) {
|
|
|
parts = line.substring(12).split(' ');
|
|
|
} else {
|
|
|
parts = line.substring(10).split(' ');
|
|
|
}
|
|
|
|
|
|
var candidate = {
|
|
|
foundation: parts[0],
|
|
|
component: parts[1],
|
|
|
protocol: parts[2].toLowerCase(),
|
|
|
priority: parseInt(parts[3], 10),
|
|
|
ip: parts[4],
|
|
|
port: parseInt(parts[5], 10),
|
|
|
// skip parts[6] == 'typ'
|
|
|
type: parts[7]
|
|
|
};
|
|
|
|
|
|
for (var i = 8; i < parts.length; i += 2) {
|
|
|
switch (parts[i]) {
|
|
|
case 'raddr':
|
|
|
candidate.relatedAddress = parts[i + 1];
|
|
|
break;
|
|
|
case 'rport':
|
|
|
candidate.relatedPort = parseInt(parts[i + 1], 10);
|
|
|
break;
|
|
|
case 'tcptype':
|
|
|
candidate.tcpType = parts[i + 1];
|
|
|
break;
|
|
|
default: // Unknown extensions are silently ignored.
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return candidate;
|
|
|
};
|
|
|
|
|
|
// Translates a candidate object into SDP candidate attribute.
|
|
|
SDPUtils.writeCandidate = function(candidate) {
|
|
|
var sdp = [];
|
|
|
sdp.push(candidate.foundation);
|
|
|
sdp.push(candidate.component);
|
|
|
sdp.push(candidate.protocol.toUpperCase());
|
|
|
sdp.push(candidate.priority);
|
|
|
sdp.push(candidate.ip);
|
|
|
sdp.push(candidate.port);
|
|
|
|
|
|
var type = candidate.type;
|
|
|
sdp.push('typ');
|
|
|
sdp.push(type);
|
|
|
if (type !== 'host' && candidate.relatedAddress &&
|
|
|
candidate.relatedPort) {
|
|
|
sdp.push('raddr');
|
|
|
sdp.push(candidate.relatedAddress); // was: relAddr
|
|
|
sdp.push('rport');
|
|
|
sdp.push(candidate.relatedPort); // was: relPort
|
|
|
}
|
|
|
if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {
|
|
|
sdp.push('tcptype');
|
|
|
sdp.push(candidate.tcpType);
|
|
|
}
|
|
|
return 'candidate:' + sdp.join(' ');
|
|
|
};
|
|
|
|
|
|
// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:
|
|
|
// a=rtpmap:111 opus/48000/2
|
|
|
SDPUtils.parseRtpMap = function(line) {
|
|
|
var parts = line.substr(9).split(' ');
|
|
|
var parsed = {
|
|
|
payloadType: parseInt(parts.shift(), 10) // was: id
|
|
|
};
|
|
|
|
|
|
parts = parts[0].split('/');
|
|
|
|
|
|
parsed.name = parts[0];
|
|
|
parsed.clockRate = parseInt(parts[1], 10); // was: clockrate
|
|
|
// was: channels
|
|
|
parsed.numChannels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
|
|
|
return parsed;
|
|
|
};
|
|
|
|
|
|
// Generate an a=rtpmap line from RTCRtpCodecCapability or
|
|
|
// RTCRtpCodecParameters.
|
|
|
SDPUtils.writeRtpMap = function(codec) {
|
|
|
var pt = codec.payloadType;
|
|
|
if (codec.preferredPayloadType !== undefined) {
|
|
|
pt = codec.preferredPayloadType;
|
|
|
}
|
|
|
return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +
|
|
|
(codec.numChannels !== 1 ? '/' + codec.numChannels : '') + '\r\n';
|
|
|
};
|
|
|
|
|
|
// Parses an a=extmap line (headerextension from RFC 5285). Sample input:
|
|
|
// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
|
|
|
SDPUtils.parseExtmap = function(line) {
|
|
|
var parts = line.substr(9).split(' ');
|
|
|
return {
|
|
|
id: parseInt(parts[0], 10),
|
|
|
uri: parts[1]
|
|
|
};
|
|
|
};
|
|
|
|
|
|
// Generates a=extmap line from RTCRtpHeaderExtensionParameters or
|
|
|
// RTCRtpHeaderExtension.
|
|
|
SDPUtils.writeExtmap = function(headerExtension) {
|
|
|
return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +
|
|
|
' ' + headerExtension.uri + '\r\n';
|
|
|
};
|
|
|
|
|
|
// Parses an ftmp line, returns dictionary. Sample input:
|
|
|
// a=fmtp:96 vbr=on;cng=on
|
|
|
// Also deals with vbr=on; cng=on
|
|
|
SDPUtils.parseFmtp = function(line) {
|
|
|
var parsed = {};
|
|
|
var kv;
|
|
|
var parts = line.substr(line.indexOf(' ') + 1).split(';');
|
|
|
for (var j = 0; j < parts.length; j++) {
|
|
|
kv = parts[j].trim().split('=');
|
|
|
parsed[kv[0].trim()] = kv[1];
|
|
|
}
|
|
|
return parsed;
|
|
|
};
|
|
|
|
|
|
// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.
|
|
|
SDPUtils.writeFmtp = function(codec) {
|
|
|
var line = '';
|
|
|
var pt = codec.payloadType;
|
|
|
if (codec.preferredPayloadType !== undefined) {
|
|
|
pt = codec.preferredPayloadType;
|
|
|
}
|
|
|
if (codec.parameters && Object.keys(codec.parameters).length) {
|
|
|
var params = [];
|
|
|
Object.keys(codec.parameters).forEach(function(param) {
|
|
|
params.push(param + '=' + codec.parameters[param]);
|
|
|
});
|
|
|
line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\r\n';
|
|
|
}
|
|
|
return line;
|
|
|
};
|
|
|
|
|
|
// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:
|
|
|
// a=rtcp-fb:98 nack rpsi
|
|
|
SDPUtils.parseRtcpFb = function(line) {
|
|
|
var parts = line.substr(line.indexOf(' ') + 1).split(' ');
|
|
|
return {
|
|
|
type: parts.shift(),
|
|
|
parameter: parts.join(' ')
|
|
|
};
|
|
|
};
|
|
|
// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.
|
|
|
SDPUtils.writeRtcpFb = function(codec) {
|
|
|
var lines = '';
|
|
|
var pt = codec.payloadType;
|
|
|
if (codec.preferredPayloadType !== undefined) {
|
|
|
pt = codec.preferredPayloadType;
|
|
|
}
|
|
|
if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
|
|
|
// FIXME: special handling for trr-int?
|
|
|
codec.rtcpFeedback.forEach(function(fb) {
|
|
|
lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +
|
|
|
(fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +
|
|
|
'\r\n';
|
|
|
});
|
|
|
}
|
|
|
return lines;
|
|
|
};
|
|
|
|
|
|
// Parses an RFC 5576 ssrc media attribute. Sample input:
|
|
|
// a=ssrc:3735928559 cname:something
|
|
|
SDPUtils.parseSsrcMedia = function(line) {
|
|
|
var sp = line.indexOf(' ');
|
|
|
var parts = {
|
|
|
ssrc: parseInt(line.substr(7, sp - 7), 10)
|
|
|
};
|
|
|
var colon = line.indexOf(':', sp);
|
|
|
if (colon > -1) {
|
|
|
parts.attribute = line.substr(sp + 1, colon - sp - 1);
|
|
|
parts.value = line.substr(colon + 1);
|
|
|
} else {
|
|
|
parts.attribute = line.substr(sp + 1);
|
|
|
}
|
|
|
return parts;
|
|
|
};
|
|
|
|
|
|
// Extracts DTLS parameters from SDP media section or sessionpart.
|
|
|
// FIXME: for consistency with other functions this should only
|
|
|
// get the fingerprint line as input. See also getIceParameters.
|
|
|
SDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {
|
|
|
var lines = SDPUtils.splitLines(mediaSection);
|
|
|
// Search in session part, too.
|
|
|
lines = lines.concat(SDPUtils.splitLines(sessionpart));
|
|
|
var fpLine = lines.filter(function(line) {
|
|
|
return line.indexOf('a=fingerprint:') === 0;
|
|
|
})[0].substr(14);
|
|
|
// Note: a=setup line is ignored since we use the 'auto' role.
|
|
|
var dtlsParameters = {
|
|
|
role: 'auto',
|
|
|
fingerprints: [{
|
|
|
algorithm: fpLine.split(' ')[0],
|
|
|
value: fpLine.split(' ')[1]
|
|
|
}]
|
|
|
};
|
|
|
return dtlsParameters;
|
|
|
};
|
|
|
|
|
|
// Serializes DTLS parameters to SDP.
|
|
|
SDPUtils.writeDtlsParameters = function(params, setupType) {
|
|
|
var sdp = 'a=setup:' + setupType + '\r\n';
|
|
|
params.fingerprints.forEach(function(fp) {
|
|
|
sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\r\n';
|
|
|
});
|
|
|
return sdp;
|
|
|
};
|
|
|
// Parses ICE information from SDP media section or sessionpart.
|
|
|
// FIXME: for consistency with other functions this should only
|
|
|
// get the ice-ufrag and ice-pwd lines as input.
|
|
|
SDPUtils.getIceParameters = function(mediaSection, sessionpart) {
|
|
|
var lines = SDPUtils.splitLines(mediaSection);
|
|
|
// Search in session part, too.
|
|
|
lines = lines.concat(SDPUtils.splitLines(sessionpart));
|
|
|
var iceParameters = {
|
|
|
usernameFragment: lines.filter(function(line) {
|
|
|
return line.indexOf('a=ice-ufrag:') === 0;
|
|
|
})[0].substr(12),
|
|
|
password: lines.filter(function(line) {
|
|
|
return line.indexOf('a=ice-pwd:') === 0;
|
|
|
})[0].substr(10)
|
|
|
};
|
|
|
return iceParameters;
|
|
|
};
|
|
|
|
|
|
// Serializes ICE parameters to SDP.
|
|
|
SDPUtils.writeIceParameters = function(params) {
|
|
|
return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
|
|
|
'a=ice-pwd:' + params.password + '\r\n';
|
|
|
};
|
|
|
|
|
|
// Parses the SDP media section and returns RTCRtpParameters.
|
|
|
SDPUtils.parseRtpParameters = function(mediaSection) {
|
|
|
var description = {
|
|
|
codecs: [],
|
|
|
headerExtensions: [],
|
|
|
fecMechanisms: [],
|
|
|
rtcp: []
|
|
|
};
|
|
|
var lines = SDPUtils.splitLines(mediaSection);
|
|
|
var mline = lines[0].split(' ');
|
|
|
for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]
|
|
|
var pt = mline[i];
|
|
|
var rtpmapline = SDPUtils.matchPrefix(
|
|
|
mediaSection, 'a=rtpmap:' + pt + ' ')[0];
|
|
|
if (rtpmapline) {
|
|
|
var codec = SDPUtils.parseRtpMap(rtpmapline);
|
|
|
var fmtps = SDPUtils.matchPrefix(
|
|
|
mediaSection, 'a=fmtp:' + pt + ' ');
|
|
|
// Only the first a=fmtp:<pt> is considered.
|
|
|
codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};
|
|
|
codec.rtcpFeedback = SDPUtils.matchPrefix(
|
|
|
mediaSection, 'a=rtcp-fb:' + pt + ' ')
|
|
|
.map(SDPUtils.parseRtcpFb);
|
|
|
description.codecs.push(codec);
|
|
|
// parse FEC mechanisms from rtpmap lines.
|
|
|
switch (codec.name.toUpperCase()) {
|
|
|
case 'RED':
|
|
|
case 'ULPFEC':
|
|
|
description.fecMechanisms.push(codec.name.toUpperCase());
|
|
|
break;
|
|
|
default: // only RED and ULPFEC are recognized as FEC mechanisms.
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {
|
|
|
description.headerExtensions.push(SDPUtils.parseExtmap(line));
|
|
|
});
|
|
|
// FIXME: parse rtcp.
|
|
|
return description;
|
|
|
};
|
|
|
|
|
|
// Generates parts of the SDP media section describing the capabilities /
|
|
|
// parameters.
|
|
|
SDPUtils.writeRtpDescription = function(kind, caps) {
|
|
|
var sdp = '';
|
|
|
|
|
|
// Build the mline.
|
|
|
sdp += 'm=' + kind + ' ';
|
|
|
sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.
|
|
|
sdp += ' UDP/TLS/RTP/SAVPF ';
|
|
|
sdp += caps.codecs.map(function(codec) {
|
|
|
if (codec.preferredPayloadType !== undefined) {
|
|
|
return codec.preferredPayloadType;
|
|
|
}
|
|
|
return codec.payloadType;
|
|
|
}).join(' ') + '\r\n';
|
|
|
|
|
|
sdp += 'c=IN IP4 0.0.0.0\r\n';
|
|
|
sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
|
|
|
|
|
|
// Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.
|
|
|
caps.codecs.forEach(function(codec) {
|
|
|
sdp += SDPUtils.writeRtpMap(codec);
|
|
|
sdp += SDPUtils.writeFmtp(codec);
|
|
|
sdp += SDPUtils.writeRtcpFb(codec);
|
|
|
});
|
|
|
var maxptime = 0;
|
|
|
caps.codecs.forEach(function(codec) {
|
|
|
if (codec.maxptime > maxptime) {
|
|
|
maxptime = codec.maxptime;
|
|
|
}
|
|
|
});
|
|
|
if (maxptime > 0) {
|
|
|
sdp += 'a=maxptime:' + maxptime + '\r\n';
|
|
|
}
|
|
|
sdp += 'a=rtcp-mux\r\n';
|
|
|
|
|
|
caps.headerExtensions.forEach(function(extension) {
|
|
|
sdp += SDPUtils.writeExtmap(extension);
|
|
|
});
|
|
|
// FIXME: write fecMechanisms.
|
|
|
return sdp;
|
|
|
};
|
|
|
|
|
|
// Parses the SDP media section and returns an array of
|
|
|
// RTCRtpEncodingParameters.
|
|
|
SDPUtils.parseRtpEncodingParameters = function(mediaSection) {
|
|
|
var encodingParameters = [];
|
|
|
var description = SDPUtils.parseRtpParameters(mediaSection);
|
|
|
var hasRed = description.fecMechanisms.indexOf('RED') !== -1;
|
|
|
var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;
|
|
|
|
|
|
// filter a=ssrc:... cname:, ignore PlanB-msid
|
|
|
var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
|
|
|
.map(function(line) {
|
|
|
return SDPUtils.parseSsrcMedia(line);
|
|
|
})
|
|
|
.filter(function(parts) {
|
|
|
return parts.attribute === 'cname';
|
|
|
});
|
|
|
var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
|
|
|
var secondarySsrc;
|
|
|
|
|
|
var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')
|
|
|
.map(function(line) {
|
|
|
var parts = line.split(' ');
|
|
|
parts.shift();
|
|
|
return parts.map(function(part) {
|
|
|
return parseInt(part, 10);
|
|
|
});
|
|
|
});
|
|
|
if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
|
|
|
secondarySsrc = flows[0][1];
|
|
|
}
|
|
|
|
|
|
description.codecs.forEach(function(codec) {
|
|
|
if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {
|
|
|
var encParam = {
|
|
|
ssrc: primarySsrc,
|
|
|
codecPayloadType: parseInt(codec.parameters.apt, 10),
|
|
|
rtx: {
|
|
|
ssrc: secondarySsrc
|
|
|
}
|
|
|
};
|
|
|
encodingParameters.push(encParam);
|
|
|
if (hasRed) {
|
|
|
encParam = JSON.parse(JSON.stringify(encParam));
|
|
|
encParam.fec = {
|
|
|
ssrc: secondarySsrc,
|
|
|
mechanism: hasUlpfec ? 'red+ulpfec' : 'red'
|
|
|
};
|
|
|
encodingParameters.push(encParam);
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
if (encodingParameters.length === 0 && primarySsrc) {
|
|
|
encodingParameters.push({
|
|
|
ssrc: primarySsrc
|
|
|
});
|
|
|
}
|
|
|
|
|
|
// we support both b=AS and b=TIAS but interpret AS as TIAS.
|
|
|
var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');
|
|
|
if (bandwidth.length) {
|
|
|
if (bandwidth[0].indexOf('b=TIAS:') === 0) {
|
|
|
bandwidth = parseInt(bandwidth[0].substr(7), 10);
|
|
|
} else if (bandwidth[0].indexOf('b=AS:') === 0) {
|
|
|
bandwidth = parseInt(bandwidth[0].substr(5), 10);
|
|
|
}
|
|
|
encodingParameters.forEach(function(params) {
|
|
|
params.maxBitrate = bandwidth;
|
|
|
});
|
|
|
}
|
|
|
return encodingParameters;
|
|
|
};
|
|
|
|
|
|
// parses http://draft.ortc.org/#rtcrtcpparameters*
|
|
|
SDPUtils.parseRtcpParameters = function(mediaSection) {
|
|
|
var rtcpParameters = {};
|
|
|
|
|
|
var cname;
|
|
|
// Gets the first SSRC. Note that with RTX there might be multiple
|
|
|
// SSRCs.
|
|
|
var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
|
|
|
.map(function(line) {
|
|
|
return SDPUtils.parseSsrcMedia(line);
|
|
|
})
|
|
|
.filter(function(obj) {
|
|
|
return obj.attribute === 'cname';
|
|
|
})[0];
|
|
|
if (remoteSsrc) {
|
|
|
rtcpParameters.cname = remoteSsrc.value;
|
|
|
rtcpParameters.ssrc = remoteSsrc.ssrc;
|
|
|
}
|
|
|
|
|
|
// Edge uses the compound attribute instead of reducedSize
|
|
|
// compound is !reducedSize
|
|
|
var rsize = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-rsize');
|
|
|
rtcpParameters.reducedSize = rsize.length > 0;
|
|
|
rtcpParameters.compound = rsize.length === 0;
|
|
|
|
|
|
// parses the rtcp-mux attrіbute.
|
|
|
// Note that Edge does not support unmuxed RTCP.
|
|
|
var mux = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-mux');
|
|
|
rtcpParameters.mux = mux.length > 0;
|
|
|
|
|
|
return rtcpParameters;
|
|
|
};
|
|
|
|
|
|
// parses either a=msid: or a=ssrc:... msid lines an returns
|
|
|
// the id of the MediaStream and MediaStreamTrack.
|
|
|
SDPUtils.parseMsid = function(mediaSection) {
|
|
|
var parts;
|
|
|
var spec = SDPUtils.matchPrefix(mediaSection, 'a=msid:');
|
|
|
if (spec.length === 1) {
|
|
|
parts = spec[0].substr(7).split(' ');
|
|
|
return {stream: parts[0], track: parts[1]};
|
|
|
}
|
|
|
var planB = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
|
|
|
.map(function(line) {
|
|
|
return SDPUtils.parseSsrcMedia(line);
|
|
|
})
|
|
|
.filter(function(parts) {
|
|
|
return parts.attribute === 'msid';
|
|
|
});
|
|
|
if (planB.length > 0) {
|
|
|
parts = planB[0].value.split(' ');
|
|
|
return {stream: parts[0], track: parts[1]};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
SDPUtils.writeSessionBoilerplate = function() {
|
|
|
// FIXME: sess-id should be an NTP timestamp.
|
|
|
return 'v=0\r\n' +
|
|
|
'o=thisisadapterortc 8169639915646943137 2 IN IP4 127.0.0.1\r\n' +
|
|
|
's=-\r\n' +
|
|
|
't=0 0\r\n';
|
|
|
};
|
|
|
|
|
|
SDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {
|
|
|
var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
|
|
|
|
|
|
// Map ICE parameters (ufrag, pwd) to SDP.
|
|
|
sdp += SDPUtils.writeIceParameters(
|
|
|
transceiver.iceGatherer.getLocalParameters());
|
|
|
|
|
|
// Map DTLS parameters to SDP.
|
|
|
sdp += SDPUtils.writeDtlsParameters(
|
|
|
transceiver.dtlsTransport.getLocalParameters(),
|
|
|
type === 'offer' ? 'actpass' : 'active');
|
|
|
|
|
|
sdp += 'a=mid:' + transceiver.mid + '\r\n';
|
|
|
|
|
|
if (transceiver.rtpSender && transceiver.rtpReceiver) {
|
|
|
sdp += 'a=sendrecv\r\n';
|
|
|
} else if (transceiver.rtpSender) {
|
|
|
sdp += 'a=sendonly\r\n';
|
|
|
} else if (transceiver.rtpReceiver) {
|
|
|
sdp += 'a=recvonly\r\n';
|
|
|
} else {
|
|
|
sdp += 'a=inactive\r\n';
|
|
|
}
|
|
|
|
|
|
if (transceiver.rtpSender) {
|
|
|
// spec.
|
|
|
var msid = 'msid:' + stream.id + ' ' +
|
|
|
transceiver.rtpSender.track.id + '\r\n';
|
|
|
sdp += 'a=' + msid;
|
|
|
|
|
|
// for Chrome.
|
|
|
sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
|
|
|
' ' + msid;
|
|
|
if (transceiver.sendEncodingParameters[0].rtx) {
|
|
|
sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
|
|
|
' ' + msid;
|
|
|
sdp += 'a=ssrc-group:FID ' +
|
|
|
transceiver.sendEncodingParameters[0].ssrc + ' ' +
|
|
|
transceiver.sendEncodingParameters[0].rtx.ssrc +
|
|
|
'\r\n';
|
|
|
}
|
|
|
}
|
|
|
// FIXME: this should be written by writeRtpDescription.
|
|
|
sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
|
|
|
' cname:' + SDPUtils.localCName + '\r\n';
|
|
|
if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {
|
|
|
sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
|
|
|
' cname:' + SDPUtils.localCName + '\r\n';
|
|
|
}
|
|
|
return sdp;
|
|
|
};
|
|
|
|
|
|
// Gets the direction from the mediaSection or the sessionpart.
|
|
|
SDPUtils.getDirection = function(mediaSection, sessionpart) {
|
|
|
// Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.
|
|
|
var lines = SDPUtils.splitLines(mediaSection);
|
|
|
for (var i = 0; i < lines.length; i++) {
|
|
|
switch (lines[i]) {
|
|
|
case 'a=sendrecv':
|
|
|
case 'a=sendonly':
|
|
|
case 'a=recvonly':
|
|
|
case 'a=inactive':
|
|
|
return lines[i].substr(2);
|
|
|
default:
|
|
|
// FIXME: What should happen here?
|
|
|
}
|
|
|
}
|
|
|
if (sessionpart) {
|
|
|
return SDPUtils.getDirection(sessionpart);
|
|
|
}
|
|
|
return 'sendrecv';
|
|
|
};
|
|
|
|
|
|
SDPUtils.getKind = function(mediaSection) {
|
|
|
var lines = SDPUtils.splitLines(mediaSection);
|
|
|
var mline = lines[0].split(' ');
|
|
|
return mline[0].substr(2);
|
|
|
};
|
|
|
|
|
|
SDPUtils.isRejected = function(mediaSection) {
|
|
|
return mediaSection.split(' ', 2)[1] === '0';
|
|
|
};
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = SDPUtils;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 203 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
|
|
|
// Shimming starts here.
|
|
|
(function() {
|
|
|
// Utils.
|
|
|
var logging = __webpack_require__(0).log;
|
|
|
var browserDetails = __webpack_require__(0).browserDetails;
|
|
|
// Export to the adapter global object visible in the browser.
|
|
|
module.exports.browserDetails = browserDetails;
|
|
|
module.exports.extractVersion = __webpack_require__(0).extractVersion;
|
|
|
module.exports.disableLog = __webpack_require__(0).disableLog;
|
|
|
|
|
|
// Uncomment the line below if you want logging to occur, including logging
|
|
|
// for the switch statement below. Can also be turned on in the browser via
|
|
|
// adapter.disableLog(false), but then logging from the switch statement below
|
|
|
// will not appear.
|
|
|
// require('./utils').disableLog(false);
|
|
|
|
|
|
// Browser shims.
|
|
|
var chromeShim = __webpack_require__(204) || null;
|
|
|
var edgeShim = __webpack_require__(206) || null;
|
|
|
var firefoxShim = __webpack_require__(208) || null;
|
|
|
var safariShim = __webpack_require__(210) || null;
|
|
|
|
|
|
// Shim browser if found.
|
|
|
switch (browserDetails.browser) {
|
|
|
case 'opera': // fallthrough as it uses chrome shims
|
|
|
case 'chrome':
|
|
|
if (!chromeShim || !chromeShim.shimPeerConnection) {
|
|
|
logging('Chrome shim is not included in this adapter release.');
|
|
|
return;
|
|
|
}
|
|
|
logging('adapter.js shimming chrome.');
|
|
|
// Export to the adapter global object visible in the browser.
|
|
|
module.exports.browserShim = chromeShim;
|
|
|
|
|
|
chromeShim.shimGetUserMedia();
|
|
|
chromeShim.shimMediaStream();
|
|
|
chromeShim.shimSourceObject();
|
|
|
chromeShim.shimPeerConnection();
|
|
|
chromeShim.shimOnTrack();
|
|
|
break;
|
|
|
case 'firefox':
|
|
|
if (!firefoxShim || !firefoxShim.shimPeerConnection) {
|
|
|
logging('Firefox shim is not included in this adapter release.');
|
|
|
return;
|
|
|
}
|
|
|
logging('adapter.js shimming firefox.');
|
|
|
// Export to the adapter global object visible in the browser.
|
|
|
module.exports.browserShim = firefoxShim;
|
|
|
|
|
|
firefoxShim.shimGetUserMedia();
|
|
|
firefoxShim.shimSourceObject();
|
|
|
firefoxShim.shimPeerConnection();
|
|
|
firefoxShim.shimOnTrack();
|
|
|
break;
|
|
|
case 'edge':
|
|
|
if (!edgeShim || !edgeShim.shimPeerConnection) {
|
|
|
logging('MS edge shim is not included in this adapter release.');
|
|
|
return;
|
|
|
}
|
|
|
logging('adapter.js shimming edge.');
|
|
|
// Export to the adapter global object visible in the browser.
|
|
|
module.exports.browserShim = edgeShim;
|
|
|
|
|
|
edgeShim.shimGetUserMedia();
|
|
|
edgeShim.shimPeerConnection();
|
|
|
break;
|
|
|
case 'safari':
|
|
|
if (!safariShim) {
|
|
|
logging('Safari shim is not included in this adapter release.');
|
|
|
return;
|
|
|
}
|
|
|
logging('adapter.js shimming safari.');
|
|
|
// Export to the adapter global object visible in the browser.
|
|
|
module.exports.browserShim = safariShim;
|
|
|
|
|
|
safariShim.shimGetUserMedia();
|
|
|
break;
|
|
|
default:
|
|
|
logging('Unsupported browser!');
|
|
|
}
|
|
|
})();
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 204 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
var logging = __webpack_require__(0).log;
|
|
|
var browserDetails = __webpack_require__(0).browserDetails;
|
|
|
|
|
|
var chromeShim = {
|
|
|
shimMediaStream: function() {
|
|
|
window.MediaStream = window.MediaStream || window.webkitMediaStream;
|
|
|
},
|
|
|
|
|
|
shimOnTrack: function() {
|
|
|
if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
|
|
|
window.RTCPeerConnection.prototype)) {
|
|
|
Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
|
|
|
get: function() {
|
|
|
return this._ontrack;
|
|
|
},
|
|
|
set: function(f) {
|
|
|
var self = this;
|
|
|
if (this._ontrack) {
|
|
|
this.removeEventListener('track', this._ontrack);
|
|
|
this.removeEventListener('addstream', this._ontrackpoly);
|
|
|
}
|
|
|
this.addEventListener('track', this._ontrack = f);
|
|
|
this.addEventListener('addstream', this._ontrackpoly = function(e) {
|
|
|
// onaddstream does not fire when a track is added to an existing
|
|
|
// stream. But stream.onaddtrack is implemented so we use that.
|
|
|
e.stream.addEventListener('addtrack', function(te) {
|
|
|
var event = new Event('track');
|
|
|
event.track = te.track;
|
|
|
event.receiver = {track: te.track};
|
|
|
event.streams = [e.stream];
|
|
|
self.dispatchEvent(event);
|
|
|
});
|
|
|
e.stream.getTracks().forEach(function(track) {
|
|
|
var event = new Event('track');
|
|
|
event.track = track;
|
|
|
event.receiver = {track: track};
|
|
|
event.streams = [e.stream];
|
|
|
this.dispatchEvent(event);
|
|
|
}.bind(this));
|
|
|
}.bind(this));
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
},
|
|
|
|
|
|
shimSourceObject: function() {
|
|
|
if (typeof window === 'object') {
|
|
|
if (window.HTMLMediaElement &&
|
|
|
!('srcObject' in window.HTMLMediaElement.prototype)) {
|
|
|
// Shim the srcObject property, once, when HTMLMediaElement is found.
|
|
|
Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {
|
|
|
get: function() {
|
|
|
return this._srcObject;
|
|
|
},
|
|
|
set: function(stream) {
|
|
|
var self = this;
|
|
|
// Use _srcObject as a private property for this shim
|
|
|
this._srcObject = stream;
|
|
|
if (this.src) {
|
|
|
URL.revokeObjectURL(this.src);
|
|
|
}
|
|
|
|
|
|
if (!stream) {
|
|
|
this.src = '';
|
|
|
return;
|
|
|
}
|
|
|
this.src = URL.createObjectURL(stream);
|
|
|
// We need to recreate the blob url when a track is added or
|
|
|
// removed. Doing it manually since we want to avoid a recursion.
|
|
|
stream.addEventListener('addtrack', function() {
|
|
|
if (self.src) {
|
|
|
URL.revokeObjectURL(self.src);
|
|
|
}
|
|
|
self.src = URL.createObjectURL(stream);
|
|
|
});
|
|
|
stream.addEventListener('removetrack', function() {
|
|
|
if (self.src) {
|
|
|
URL.revokeObjectURL(self.src);
|
|
|
}
|
|
|
self.src = URL.createObjectURL(stream);
|
|
|
});
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
|
|
|
shimPeerConnection: function() {
|
|
|
// The RTCPeerConnection object.
|
|
|
window.RTCPeerConnection = function(pcConfig, pcConstraints) {
|
|
|
// Translate iceTransportPolicy to iceTransports,
|
|
|
// see https://code.google.com/p/webrtc/issues/detail?id=4869
|
|
|
logging('PeerConnection');
|
|
|
if (pcConfig && pcConfig.iceTransportPolicy) {
|
|
|
pcConfig.iceTransports = pcConfig.iceTransportPolicy;
|
|
|
}
|
|
|
|
|
|
var pc = new webkitRTCPeerConnection(pcConfig, pcConstraints);
|
|
|
var origGetStats = pc.getStats.bind(pc);
|
|
|
pc.getStats = function(selector, successCallback, errorCallback) {
|
|
|
var self = this;
|
|
|
var args = arguments;
|
|
|
|
|
|
// If selector is a function then we are in the old style stats so just
|
|
|
// pass back the original getStats format to avoid breaking old users.
|
|
|
if (arguments.length > 0 && typeof selector === 'function') {
|
|
|
return origGetStats(selector, successCallback);
|
|
|
}
|
|
|
|
|
|
var fixChromeStats_ = function(response) {
|
|
|
var standardReport = {};
|
|
|
var reports = response.result();
|
|
|
reports.forEach(function(report) {
|
|
|
var standardStats = {
|
|
|
id: report.id,
|
|
|
timestamp: report.timestamp,
|
|
|
type: report.type
|
|
|
};
|
|
|
report.names().forEach(function(name) {
|
|
|
standardStats[name] = report.stat(name);
|
|
|
});
|
|
|
standardReport[standardStats.id] = standardStats;
|
|
|
});
|
|
|
|
|
|
return standardReport;
|
|
|
};
|
|
|
|
|
|
// shim getStats with maplike support
|
|
|
var makeMapStats = function(stats, legacyStats) {
|
|
|
var map = new Map(Object.keys(stats).map(function(key) {
|
|
|
return[key, stats[key]];
|
|
|
}));
|
|
|
legacyStats = legacyStats || stats;
|
|
|
Object.keys(legacyStats).forEach(function(key) {
|
|
|
map[key] = legacyStats[key];
|
|
|
});
|
|
|
return map;
|
|
|
};
|
|
|
|
|
|
if (arguments.length >= 2) {
|
|
|
var successCallbackWrapper_ = function(response) {
|
|
|
args[1](makeMapStats(fixChromeStats_(response)));
|
|
|
};
|
|
|
|
|
|
return origGetStats.apply(this, [successCallbackWrapper_,
|
|
|
arguments[0]]);
|
|
|
}
|
|
|
|
|
|
// promise-support
|
|
|
return new Promise(function(resolve, reject) {
|
|
|
if (args.length === 1 && typeof selector === 'object') {
|
|
|
origGetStats.apply(self, [
|
|
|
function(response) {
|
|
|
resolve(makeMapStats(fixChromeStats_(response)));
|
|
|
}, reject]);
|
|
|
} else {
|
|
|
// Preserve legacy chrome stats only on legacy access of stats obj
|
|
|
origGetStats.apply(self, [
|
|
|
function(response) {
|
|
|
resolve(makeMapStats(fixChromeStats_(response),
|
|
|
response.result()));
|
|
|
}, reject]);
|
|
|
}
|
|
|
}).then(successCallback, errorCallback);
|
|
|
};
|
|
|
|
|
|
return pc;
|
|
|
};
|
|
|
window.RTCPeerConnection.prototype = webkitRTCPeerConnection.prototype;
|
|
|
|
|
|
// wrap static methods. Currently just generateCertificate.
|
|
|
if (webkitRTCPeerConnection.generateCertificate) {
|
|
|
Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
|
|
|
get: function() {
|
|
|
return webkitRTCPeerConnection.generateCertificate;
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
['createOffer', 'createAnswer'].forEach(function(method) {
|
|
|
var nativeMethod = webkitRTCPeerConnection.prototype[method];
|
|
|
webkitRTCPeerConnection.prototype[method] = function() {
|
|
|
var self = this;
|
|
|
if (arguments.length < 1 || (arguments.length === 1 &&
|
|
|
typeof arguments[0] === 'object')) {
|
|
|
var opts = arguments.length === 1 ? arguments[0] : undefined;
|
|
|
return new Promise(function(resolve, reject) {
|
|
|
nativeMethod.apply(self, [resolve, reject, opts]);
|
|
|
});
|
|
|
}
|
|
|
return nativeMethod.apply(this, arguments);
|
|
|
};
|
|
|
});
|
|
|
|
|
|
// add promise support -- natively available in Chrome 51
|
|
|
if (browserDetails.version < 51) {
|
|
|
['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
|
|
|
.forEach(function(method) {
|
|
|
var nativeMethod = webkitRTCPeerConnection.prototype[method];
|
|
|
webkitRTCPeerConnection.prototype[method] = function() {
|
|
|
var args = arguments;
|
|
|
var self = this;
|
|
|
var promise = new Promise(function(resolve, reject) {
|
|
|
nativeMethod.apply(self, [args[0], resolve, reject]);
|
|
|
});
|
|
|
if (args.length < 2) {
|
|
|
return promise;
|
|
|
}
|
|
|
return promise.then(function() {
|
|
|
args[1].apply(null, []);
|
|
|
},
|
|
|
function(err) {
|
|
|
if (args.length >= 3) {
|
|
|
args[2].apply(null, [err]);
|
|
|
}
|
|
|
});
|
|
|
};
|
|
|
});
|
|
|
}
|
|
|
|
|
|
// shim implicit creation of RTCSessionDescription/RTCIceCandidate
|
|
|
['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
|
|
|
.forEach(function(method) {
|
|
|
var nativeMethod = webkitRTCPeerConnection.prototype[method];
|
|
|
webkitRTCPeerConnection.prototype[method] = function() {
|
|
|
arguments[0] = new ((method === 'addIceCandidate') ?
|
|
|
RTCIceCandidate : RTCSessionDescription)(arguments[0]);
|
|
|
return nativeMethod.apply(this, arguments);
|
|
|
};
|
|
|
});
|
|
|
|
|
|
// support for addIceCandidate(null or undefined)
|
|
|
var nativeAddIceCandidate =
|
|
|
RTCPeerConnection.prototype.addIceCandidate;
|
|
|
RTCPeerConnection.prototype.addIceCandidate = function() {
|
|
|
if (!arguments[0]) {
|
|
|
if (arguments[1]) {
|
|
|
arguments[1].apply(null);
|
|
|
}
|
|
|
return Promise.resolve();
|
|
|
}
|
|
|
return nativeAddIceCandidate.apply(this, arguments);
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = {
|
|
|
shimMediaStream: chromeShim.shimMediaStream,
|
|
|
shimOnTrack: chromeShim.shimOnTrack,
|
|
|
shimSourceObject: chromeShim.shimSourceObject,
|
|
|
shimPeerConnection: chromeShim.shimPeerConnection,
|
|
|
shimGetUserMedia: __webpack_require__(205)
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 205 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
var logging = __webpack_require__(0).log;
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = function() {
|
|
|
var constraintsToChrome_ = function(c) {
|
|
|
if (typeof c !== 'object' || c.mandatory || c.optional) {
|
|
|
return c;
|
|
|
}
|
|
|
var cc = {};
|
|
|
Object.keys(c).forEach(function(key) {
|
|
|
if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
|
|
|
return;
|
|
|
}
|
|
|
var r = (typeof c[key] === 'object') ? c[key] : {ideal: c[key]};
|
|
|
if (r.exact !== undefined && typeof r.exact === 'number') {
|
|
|
r.min = r.max = r.exact;
|
|
|
}
|
|
|
var oldname_ = function(prefix, name) {
|
|
|
if (prefix) {
|
|
|
return prefix + name.charAt(0).toUpperCase() + name.slice(1);
|
|
|
}
|
|
|
return (name === 'deviceId') ? 'sourceId' : name;
|
|
|
};
|
|
|
if (r.ideal !== undefined) {
|
|
|
cc.optional = cc.optional || [];
|
|
|
var oc = {};
|
|
|
if (typeof r.ideal === 'number') {
|
|
|
oc[oldname_('min', key)] = r.ideal;
|
|
|
cc.optional.push(oc);
|
|
|
oc = {};
|
|
|
oc[oldname_('max', key)] = r.ideal;
|
|
|
cc.optional.push(oc);
|
|
|
} else {
|
|
|
oc[oldname_('', key)] = r.ideal;
|
|
|
cc.optional.push(oc);
|
|
|
}
|
|
|
}
|
|
|
if (r.exact !== undefined && typeof r.exact !== 'number') {
|
|
|
cc.mandatory = cc.mandatory || {};
|
|
|
cc.mandatory[oldname_('', key)] = r.exact;
|
|
|
} else {
|
|
|
['min', 'max'].forEach(function(mix) {
|
|
|
if (r[mix] !== undefined) {
|
|
|
cc.mandatory = cc.mandatory || {};
|
|
|
cc.mandatory[oldname_(mix, key)] = r[mix];
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
});
|
|
|
if (c.advanced) {
|
|
|
cc.optional = (cc.optional || []).concat(c.advanced);
|
|
|
}
|
|
|
return cc;
|
|
|
};
|
|
|
|
|
|
var shimConstraints_ = function(constraints, func) {
|
|
|
constraints = JSON.parse(JSON.stringify(constraints));
|
|
|
if (constraints && constraints.audio) {
|
|
|
constraints.audio = constraintsToChrome_(constraints.audio);
|
|
|
}
|
|
|
if (constraints && typeof constraints.video === 'object') {
|
|
|
// Shim facingMode for mobile, where it defaults to "user".
|
|
|
var face = constraints.video.facingMode;
|
|
|
face = face && ((typeof face === 'object') ? face : {ideal: face});
|
|
|
|
|
|
if ((face && (face.exact === 'user' || face.exact === 'environment' ||
|
|
|
face.ideal === 'user' || face.ideal === 'environment')) &&
|
|
|
!(navigator.mediaDevices.getSupportedConstraints &&
|
|
|
navigator.mediaDevices.getSupportedConstraints().facingMode)) {
|
|
|
delete constraints.video.facingMode;
|
|
|
if (face.exact === 'environment' || face.ideal === 'environment') {
|
|
|
// Look for "back" in label, or use last cam (typically back cam).
|
|
|
return navigator.mediaDevices.enumerateDevices()
|
|
|
.then(function(devices) {
|
|
|
devices = devices.filter(function(d) {
|
|
|
return d.kind === 'videoinput';
|
|
|
});
|
|
|
var back = devices.find(function(d) {
|
|
|
return d.label.toLowerCase().indexOf('back') !== -1;
|
|
|
}) || (devices.length && devices[devices.length - 1]);
|
|
|
if (back) {
|
|
|
constraints.video.deviceId = face.exact ? {exact: back.deviceId} :
|
|
|
{ideal: back.deviceId};
|
|
|
}
|
|
|
constraints.video = constraintsToChrome_(constraints.video);
|
|
|
logging('chrome: ' + JSON.stringify(constraints));
|
|
|
return func(constraints);
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
constraints.video = constraintsToChrome_(constraints.video);
|
|
|
}
|
|
|
logging('chrome: ' + JSON.stringify(constraints));
|
|
|
return func(constraints);
|
|
|
};
|
|
|
|
|
|
var shimError_ = function(e) {
|
|
|
return {
|
|
|
name: {
|
|
|
PermissionDeniedError: 'NotAllowedError',
|
|
|
ConstraintNotSatisfiedError: 'OverconstrainedError'
|
|
|
}[e.name] || e.name,
|
|
|
message: e.message,
|
|
|
constraint: e.constraintName,
|
|
|
toString: function() {
|
|
|
return this.name + (this.message && ': ') + this.message;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
var getUserMedia_ = function(constraints, onSuccess, onError) {
|
|
|
shimConstraints_(constraints, function(c) {
|
|
|
navigator.webkitGetUserMedia(c, onSuccess, function(e) {
|
|
|
onError(shimError_(e));
|
|
|
});
|
|
|
});
|
|
|
};
|
|
|
|
|
|
navigator.getUserMedia = getUserMedia_;
|
|
|
|
|
|
// Returns the result of getUserMedia as a Promise.
|
|
|
var getUserMediaPromise_ = function(constraints) {
|
|
|
return new Promise(function(resolve, reject) {
|
|
|
navigator.getUserMedia(constraints, resolve, reject);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
if (!navigator.mediaDevices) {
|
|
|
navigator.mediaDevices = {
|
|
|
getUserMedia: getUserMediaPromise_,
|
|
|
enumerateDevices: function() {
|
|
|
return new Promise(function(resolve) {
|
|
|
var kinds = {audio: 'audioinput', video: 'videoinput'};
|
|
|
return MediaStreamTrack.getSources(function(devices) {
|
|
|
resolve(devices.map(function(device) {
|
|
|
return {label: device.label,
|
|
|
kind: kinds[device.kind],
|
|
|
deviceId: device.id,
|
|
|
groupId: ''};
|
|
|
}));
|
|
|
});
|
|
|
});
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
|
|
|
// A shim for getUserMedia method on the mediaDevices object.
|
|
|
// TODO(KaptenJansson) remove once implemented in Chrome stable.
|
|
|
if (!navigator.mediaDevices.getUserMedia) {
|
|
|
navigator.mediaDevices.getUserMedia = function(constraints) {
|
|
|
return getUserMediaPromise_(constraints);
|
|
|
};
|
|
|
} else {
|
|
|
// Even though Chrome 45 has navigator.mediaDevices and a getUserMedia
|
|
|
// function which returns a Promise, it does not accept spec-style
|
|
|
// constraints.
|
|
|
var origGetUserMedia = navigator.mediaDevices.getUserMedia.
|
|
|
bind(navigator.mediaDevices);
|
|
|
navigator.mediaDevices.getUserMedia = function(cs) {
|
|
|
return shimConstraints_(cs, function(c) {
|
|
|
return origGetUserMedia(c).then(function(stream) {
|
|
|
if (c.audio && !stream.getAudioTracks().length ||
|
|
|
c.video && !stream.getVideoTracks().length) {
|
|
|
stream.getTracks().forEach(function(track) {
|
|
|
track.stop();
|
|
|
});
|
|
|
throw new DOMException('', 'NotFoundError');
|
|
|
}
|
|
|
return stream;
|
|
|
}, function(e) {
|
|
|
return Promise.reject(shimError_(e));
|
|
|
});
|
|
|
});
|
|
|
};
|
|
|
}
|
|
|
|
|
|
// Dummy devicechange event methods.
|
|
|
// TODO(KaptenJansson) remove once implemented in Chrome stable.
|
|
|
if (typeof navigator.mediaDevices.addEventListener === 'undefined') {
|
|
|
navigator.mediaDevices.addEventListener = function() {
|
|
|
logging('Dummy mediaDevices.addEventListener called.');
|
|
|
};
|
|
|
}
|
|
|
if (typeof navigator.mediaDevices.removeEventListener === 'undefined') {
|
|
|
navigator.mediaDevices.removeEventListener = function() {
|
|
|
logging('Dummy mediaDevices.removeEventListener called.');
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 206 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
var SDPUtils = __webpack_require__(202);
|
|
|
var browserDetails = __webpack_require__(0).browserDetails;
|
|
|
|
|
|
var edgeShim = {
|
|
|
shimPeerConnection: function() {
|
|
|
if (window.RTCIceGatherer) {
|
|
|
// ORTC defines an RTCIceCandidate object but no constructor.
|
|
|
// Not implemented in Edge.
|
|
|
if (!window.RTCIceCandidate) {
|
|
|
window.RTCIceCandidate = function(args) {
|
|
|
return args;
|
|
|
};
|
|
|
}
|
|
|
// ORTC does not have a session description object but
|
|
|
// other browsers (i.e. Chrome) that will support both PC and ORTC
|
|
|
// in the future might have this defined already.
|
|
|
if (!window.RTCSessionDescription) {
|
|
|
window.RTCSessionDescription = function(args) {
|
|
|
return args;
|
|
|
};
|
|
|
}
|
|
|
// this adds an additional event listener to MediaStrackTrack that signals
|
|
|
// when a tracks enabled property was changed.
|
|
|
var origMSTEnabled = Object.getOwnPropertyDescriptor(
|
|
|
MediaStreamTrack.prototype, 'enabled');
|
|
|
Object.defineProperty(MediaStreamTrack.prototype, 'enabled', {
|
|
|
set: function(value) {
|
|
|
origMSTEnabled.set.call(this, value);
|
|
|
var ev = new Event('enabled');
|
|
|
ev.enabled = value;
|
|
|
this.dispatchEvent(ev);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
window.RTCPeerConnection = function(config) {
|
|
|
var self = this;
|
|
|
|
|
|
var _eventTarget = document.createDocumentFragment();
|
|
|
['addEventListener', 'removeEventListener', 'dispatchEvent']
|
|
|
.forEach(function(method) {
|
|
|
self[method] = _eventTarget[method].bind(_eventTarget);
|
|
|
});
|
|
|
|
|
|
this.onicecandidate = null;
|
|
|
this.onaddstream = null;
|
|
|
this.ontrack = null;
|
|
|
this.onremovestream = null;
|
|
|
this.onsignalingstatechange = null;
|
|
|
this.oniceconnectionstatechange = null;
|
|
|
this.onnegotiationneeded = null;
|
|
|
this.ondatachannel = null;
|
|
|
|
|
|
this.localStreams = [];
|
|
|
this.remoteStreams = [];
|
|
|
this.getLocalStreams = function() {
|
|
|
return self.localStreams;
|
|
|
};
|
|
|
this.getRemoteStreams = function() {
|
|
|
return self.remoteStreams;
|
|
|
};
|
|
|
|
|
|
this.localDescription = new RTCSessionDescription({
|
|
|
type: '',
|
|
|
sdp: ''
|
|
|
});
|
|
|
this.remoteDescription = new RTCSessionDescription({
|
|
|
type: '',
|
|
|
sdp: ''
|
|
|
});
|
|
|
this.signalingState = 'stable';
|
|
|
this.iceConnectionState = 'new';
|
|
|
this.iceGatheringState = 'new';
|
|
|
|
|
|
this.iceOptions = {
|
|
|
gatherPolicy: 'all',
|
|
|
iceServers: []
|
|
|
};
|
|
|
if (config && config.iceTransportPolicy) {
|
|
|
switch (config.iceTransportPolicy) {
|
|
|
case 'all':
|
|
|
case 'relay':
|
|
|
this.iceOptions.gatherPolicy = config.iceTransportPolicy;
|
|
|
break;
|
|
|
case 'none':
|
|
|
// FIXME: remove once implementation and spec have added this.
|
|
|
throw new TypeError('iceTransportPolicy "none" not supported');
|
|
|
default:
|
|
|
// don't set iceTransportPolicy.
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
this.usingBundle = config && config.bundlePolicy === 'max-bundle';
|
|
|
|
|
|
if (config && config.iceServers) {
|
|
|
// Edge does not like
|
|
|
// 1) stun:
|
|
|
// 2) turn: that does not have all of turn:host:port?transport=udp
|
|
|
// 3) turn: with ipv6 addresses
|
|
|
var iceServers = JSON.parse(JSON.stringify(config.iceServers));
|
|
|
this.iceOptions.iceServers = iceServers.filter(function(server) {
|
|
|
if (server && server.urls) {
|
|
|
var urls = server.urls;
|
|
|
if (typeof urls === 'string') {
|
|
|
urls = [urls];
|
|
|
}
|
|
|
urls = urls.filter(function(url) {
|
|
|
return (url.indexOf('turn:') === 0 &&
|
|
|
url.indexOf('transport=udp') !== -1 &&
|
|
|
url.indexOf('turn:[') === -1) ||
|
|
|
(url.indexOf('stun:') === 0 &&
|
|
|
browserDetails.version >= 14393);
|
|
|
})[0];
|
|
|
return !!urls;
|
|
|
}
|
|
|
return false;
|
|
|
});
|
|
|
}
|
|
|
this._config = config;
|
|
|
|
|
|
// per-track iceGathers, iceTransports, dtlsTransports, rtpSenders, ...
|
|
|
// everything that is needed to describe a SDP m-line.
|
|
|
this.transceivers = [];
|
|
|
|
|
|
// since the iceGatherer is currently created in createOffer but we
|
|
|
// must not emit candidates until after setLocalDescription we buffer
|
|
|
// them in this array.
|
|
|
this._localIceCandidatesBuffer = [];
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype._emitBufferedCandidates = function() {
|
|
|
var self = this;
|
|
|
var sections = SDPUtils.splitSections(self.localDescription.sdp);
|
|
|
// FIXME: need to apply ice candidates in a way which is async but
|
|
|
// in-order
|
|
|
this._localIceCandidatesBuffer.forEach(function(event) {
|
|
|
var end = !event.candidate || Object.keys(event.candidate).length === 0;
|
|
|
if (end) {
|
|
|
for (var j = 1; j < sections.length; j++) {
|
|
|
if (sections[j].indexOf('\r\na=end-of-candidates\r\n') === -1) {
|
|
|
sections[j] += 'a=end-of-candidates\r\n';
|
|
|
}
|
|
|
}
|
|
|
} else if (event.candidate.candidate.indexOf('typ endOfCandidates')
|
|
|
=== -1) {
|
|
|
sections[event.candidate.sdpMLineIndex + 1] +=
|
|
|
'a=' + event.candidate.candidate + '\r\n';
|
|
|
}
|
|
|
self.localDescription.sdp = sections.join('');
|
|
|
self.dispatchEvent(event);
|
|
|
if (self.onicecandidate !== null) {
|
|
|
self.onicecandidate(event);
|
|
|
}
|
|
|
if (!event.candidate && self.iceGatheringState !== 'complete') {
|
|
|
var complete = self.transceivers.every(function(transceiver) {
|
|
|
return transceiver.iceGatherer &&
|
|
|
transceiver.iceGatherer.state === 'completed';
|
|
|
});
|
|
|
if (complete) {
|
|
|
self.iceGatheringState = 'complete';
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
this._localIceCandidatesBuffer = [];
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.getConfiguration = function() {
|
|
|
return this._config;
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.addStream = function(stream) {
|
|
|
// Clone is necessary for local demos mostly, attaching directly
|
|
|
// to two different senders does not work (build 10547).
|
|
|
var clonedStream = stream.clone();
|
|
|
stream.getTracks().forEach(function(track, idx) {
|
|
|
var clonedTrack = clonedStream.getTracks()[idx];
|
|
|
track.addEventListener('enabled', function(event) {
|
|
|
clonedTrack.enabled = event.enabled;
|
|
|
});
|
|
|
});
|
|
|
this.localStreams.push(clonedStream);
|
|
|
this._maybeFireNegotiationNeeded();
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.removeStream = function(stream) {
|
|
|
var idx = this.localStreams.indexOf(stream);
|
|
|
if (idx > -1) {
|
|
|
this.localStreams.splice(idx, 1);
|
|
|
this._maybeFireNegotiationNeeded();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.getSenders = function() {
|
|
|
return this.transceivers.filter(function(transceiver) {
|
|
|
return !!transceiver.rtpSender;
|
|
|
})
|
|
|
.map(function(transceiver) {
|
|
|
return transceiver.rtpSender;
|
|
|
});
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.getReceivers = function() {
|
|
|
return this.transceivers.filter(function(transceiver) {
|
|
|
return !!transceiver.rtpReceiver;
|
|
|
})
|
|
|
.map(function(transceiver) {
|
|
|
return transceiver.rtpReceiver;
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// Determines the intersection of local and remote capabilities.
|
|
|
window.RTCPeerConnection.prototype._getCommonCapabilities =
|
|
|
function(localCapabilities, remoteCapabilities) {
|
|
|
var commonCapabilities = {
|
|
|
codecs: [],
|
|
|
headerExtensions: [],
|
|
|
fecMechanisms: []
|
|
|
};
|
|
|
localCapabilities.codecs.forEach(function(lCodec) {
|
|
|
for (var i = 0; i < remoteCapabilities.codecs.length; i++) {
|
|
|
var rCodec = remoteCapabilities.codecs[i];
|
|
|
if (lCodec.name.toLowerCase() === rCodec.name.toLowerCase() &&
|
|
|
lCodec.clockRate === rCodec.clockRate) {
|
|
|
// number of channels is the highest common number of channels
|
|
|
rCodec.numChannels = Math.min(lCodec.numChannels,
|
|
|
rCodec.numChannels);
|
|
|
// push rCodec so we reply with offerer payload type
|
|
|
commonCapabilities.codecs.push(rCodec);
|
|
|
|
|
|
// determine common feedback mechanisms
|
|
|
rCodec.rtcpFeedback = rCodec.rtcpFeedback.filter(function(fb) {
|
|
|
for (var j = 0; j < lCodec.rtcpFeedback.length; j++) {
|
|
|
if (lCodec.rtcpFeedback[j].type === fb.type &&
|
|
|
lCodec.rtcpFeedback[j].parameter === fb.parameter) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
});
|
|
|
// FIXME: also need to determine .parameters
|
|
|
// see https://github.com/openpeer/ortc/issues/569
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
localCapabilities.headerExtensions
|
|
|
.forEach(function(lHeaderExtension) {
|
|
|
for (var i = 0; i < remoteCapabilities.headerExtensions.length;
|
|
|
i++) {
|
|
|
var rHeaderExtension = remoteCapabilities.headerExtensions[i];
|
|
|
if (lHeaderExtension.uri === rHeaderExtension.uri) {
|
|
|
commonCapabilities.headerExtensions.push(rHeaderExtension);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
// FIXME: fecMechanisms
|
|
|
return commonCapabilities;
|
|
|
};
|
|
|
|
|
|
// Create ICE gatherer, ICE transport and DTLS transport.
|
|
|
window.RTCPeerConnection.prototype._createIceAndDtlsTransports =
|
|
|
function(mid, sdpMLineIndex) {
|
|
|
var self = this;
|
|
|
var iceGatherer = new RTCIceGatherer(self.iceOptions);
|
|
|
var iceTransport = new RTCIceTransport(iceGatherer);
|
|
|
iceGatherer.onlocalcandidate = function(evt) {
|
|
|
var event = new Event('icecandidate');
|
|
|
event.candidate = {sdpMid: mid, sdpMLineIndex: sdpMLineIndex};
|
|
|
|
|
|
var cand = evt.candidate;
|
|
|
var end = !cand || Object.keys(cand).length === 0;
|
|
|
// Edge emits an empty object for RTCIceCandidateComplete‥
|
|
|
if (end) {
|
|
|
// polyfill since RTCIceGatherer.state is not implemented in
|
|
|
// Edge 10547 yet.
|
|
|
if (iceGatherer.state === undefined) {
|
|
|
iceGatherer.state = 'completed';
|
|
|
}
|
|
|
|
|
|
// Emit a candidate with type endOfCandidates to make the samples
|
|
|
// work. Edge requires addIceCandidate with this empty candidate
|
|
|
// to start checking. The real solution is to signal
|
|
|
// end-of-candidates to the other side when getting the null
|
|
|
// candidate but some apps (like the samples) don't do that.
|
|
|
event.candidate.candidate =
|
|
|
'candidate:1 1 udp 1 0.0.0.0 9 typ endOfCandidates';
|
|
|
} else {
|
|
|
// RTCIceCandidate doesn't have a component, needs to be added
|
|
|
cand.component = iceTransport.component === 'RTCP' ? 2 : 1;
|
|
|
event.candidate.candidate = SDPUtils.writeCandidate(cand);
|
|
|
}
|
|
|
|
|
|
// update local description.
|
|
|
var sections = SDPUtils.splitSections(self.localDescription.sdp);
|
|
|
if (event.candidate.candidate.indexOf('typ endOfCandidates')
|
|
|
=== -1) {
|
|
|
sections[event.candidate.sdpMLineIndex + 1] +=
|
|
|
'a=' + event.candidate.candidate + '\r\n';
|
|
|
} else {
|
|
|
sections[event.candidate.sdpMLineIndex + 1] +=
|
|
|
'a=end-of-candidates\r\n';
|
|
|
}
|
|
|
self.localDescription.sdp = sections.join('');
|
|
|
|
|
|
var complete = self.transceivers.every(function(transceiver) {
|
|
|
return transceiver.iceGatherer &&
|
|
|
transceiver.iceGatherer.state === 'completed';
|
|
|
});
|
|
|
|
|
|
// Emit candidate if localDescription is set.
|
|
|
// Also emits null candidate when all gatherers are complete.
|
|
|
switch (self.iceGatheringState) {
|
|
|
case 'new':
|
|
|
self._localIceCandidatesBuffer.push(event);
|
|
|
if (end && complete) {
|
|
|
self._localIceCandidatesBuffer.push(
|
|
|
new Event('icecandidate'));
|
|
|
}
|
|
|
break;
|
|
|
case 'gathering':
|
|
|
self._emitBufferedCandidates();
|
|
|
self.dispatchEvent(event);
|
|
|
if (self.onicecandidate !== null) {
|
|
|
self.onicecandidate(event);
|
|
|
}
|
|
|
if (complete) {
|
|
|
self.dispatchEvent(new Event('icecandidate'));
|
|
|
if (self.onicecandidate !== null) {
|
|
|
self.onicecandidate(new Event('icecandidate'));
|
|
|
}
|
|
|
self.iceGatheringState = 'complete';
|
|
|
}
|
|
|
break;
|
|
|
case 'complete':
|
|
|
// should not happen... currently!
|
|
|
break;
|
|
|
default: // no-op.
|
|
|
break;
|
|
|
}
|
|
|
};
|
|
|
iceTransport.onicestatechange = function() {
|
|
|
self._updateConnectionState();
|
|
|
};
|
|
|
|
|
|
var dtlsTransport = new RTCDtlsTransport(iceTransport);
|
|
|
dtlsTransport.ondtlsstatechange = function() {
|
|
|
self._updateConnectionState();
|
|
|
};
|
|
|
dtlsTransport.onerror = function() {
|
|
|
// onerror does not set state to failed by itself.
|
|
|
dtlsTransport.state = 'failed';
|
|
|
self._updateConnectionState();
|
|
|
};
|
|
|
|
|
|
return {
|
|
|
iceGatherer: iceGatherer,
|
|
|
iceTransport: iceTransport,
|
|
|
dtlsTransport: dtlsTransport
|
|
|
};
|
|
|
};
|
|
|
|
|
|
// Start the RTP Sender and Receiver for a transceiver.
|
|
|
window.RTCPeerConnection.prototype._transceive = function(transceiver,
|
|
|
send, recv) {
|
|
|
var params = this._getCommonCapabilities(transceiver.localCapabilities,
|
|
|
transceiver.remoteCapabilities);
|
|
|
if (send && transceiver.rtpSender) {
|
|
|
params.encodings = transceiver.sendEncodingParameters;
|
|
|
params.rtcp = {
|
|
|
cname: SDPUtils.localCName
|
|
|
};
|
|
|
if (transceiver.recvEncodingParameters.length) {
|
|
|
params.rtcp.ssrc = transceiver.recvEncodingParameters[0].ssrc;
|
|
|
}
|
|
|
transceiver.rtpSender.send(params);
|
|
|
}
|
|
|
if (recv && transceiver.rtpReceiver) {
|
|
|
// remove RTX field in Edge 14942
|
|
|
if (transceiver.kind === 'video'
|
|
|
&& transceiver.recvEncodingParameters) {
|
|
|
transceiver.recvEncodingParameters.forEach(function(p) {
|
|
|
delete p.rtx;
|
|
|
});
|
|
|
}
|
|
|
params.encodings = transceiver.recvEncodingParameters;
|
|
|
params.rtcp = {
|
|
|
cname: transceiver.cname
|
|
|
};
|
|
|
if (transceiver.sendEncodingParameters.length) {
|
|
|
params.rtcp.ssrc = transceiver.sendEncodingParameters[0].ssrc;
|
|
|
}
|
|
|
transceiver.rtpReceiver.receive(params);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.setLocalDescription =
|
|
|
function(description) {
|
|
|
var self = this;
|
|
|
var sections;
|
|
|
var sessionpart;
|
|
|
if (description.type === 'offer') {
|
|
|
// FIXME: What was the purpose of this empty if statement?
|
|
|
// if (!this._pendingOffer) {
|
|
|
// } else {
|
|
|
if (this._pendingOffer) {
|
|
|
// VERY limited support for SDP munging. Limited to:
|
|
|
// * changing the order of codecs
|
|
|
sections = SDPUtils.splitSections(description.sdp);
|
|
|
sessionpart = sections.shift();
|
|
|
sections.forEach(function(mediaSection, sdpMLineIndex) {
|
|
|
var caps = SDPUtils.parseRtpParameters(mediaSection);
|
|
|
self._pendingOffer[sdpMLineIndex].localCapabilities = caps;
|
|
|
});
|
|
|
this.transceivers = this._pendingOffer;
|
|
|
delete this._pendingOffer;
|
|
|
}
|
|
|
} else if (description.type === 'answer') {
|
|
|
sections = SDPUtils.splitSections(self.remoteDescription.sdp);
|
|
|
sessionpart = sections.shift();
|
|
|
var isIceLite = SDPUtils.matchPrefix(sessionpart,
|
|
|
'a=ice-lite').length > 0;
|
|
|
sections.forEach(function(mediaSection, sdpMLineIndex) {
|
|
|
var transceiver = self.transceivers[sdpMLineIndex];
|
|
|
var iceGatherer = transceiver.iceGatherer;
|
|
|
var iceTransport = transceiver.iceTransport;
|
|
|
var dtlsTransport = transceiver.dtlsTransport;
|
|
|
var localCapabilities = transceiver.localCapabilities;
|
|
|
var remoteCapabilities = transceiver.remoteCapabilities;
|
|
|
|
|
|
var rejected = mediaSection.split('\n', 1)[0]
|
|
|
.split(' ', 2)[1] === '0';
|
|
|
|
|
|
if (!rejected && !transceiver.isDatachannel) {
|
|
|
var remoteIceParameters = SDPUtils.getIceParameters(
|
|
|
mediaSection, sessionpart);
|
|
|
if (isIceLite) {
|
|
|
var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')
|
|
|
.map(function(cand) {
|
|
|
return SDPUtils.parseCandidate(cand);
|
|
|
})
|
|
|
.filter(function(cand) {
|
|
|
return cand.component === '1';
|
|
|
});
|
|
|
// ice-lite only includes host candidates in the SDP so we can
|
|
|
// use setRemoteCandidates (which implies an
|
|
|
// RTCIceCandidateComplete)
|
|
|
if (cands.length) {
|
|
|
iceTransport.setRemoteCandidates(cands);
|
|
|
}
|
|
|
}
|
|
|
var remoteDtlsParameters = SDPUtils.getDtlsParameters(
|
|
|
mediaSection, sessionpart);
|
|
|
if (isIceLite) {
|
|
|
remoteDtlsParameters.role = 'server';
|
|
|
}
|
|
|
|
|
|
if (!self.usingBundle || sdpMLineIndex === 0) {
|
|
|
iceTransport.start(iceGatherer, remoteIceParameters,
|
|
|
isIceLite ? 'controlling' : 'controlled');
|
|
|
dtlsTransport.start(remoteDtlsParameters);
|
|
|
}
|
|
|
|
|
|
// Calculate intersection of capabilities.
|
|
|
var params = self._getCommonCapabilities(localCapabilities,
|
|
|
remoteCapabilities);
|
|
|
|
|
|
// Start the RTCRtpSender. The RTCRtpReceiver for this
|
|
|
// transceiver has already been started in setRemoteDescription.
|
|
|
self._transceive(transceiver,
|
|
|
params.codecs.length > 0,
|
|
|
false);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
this.localDescription = {
|
|
|
type: description.type,
|
|
|
sdp: description.sdp
|
|
|
};
|
|
|
switch (description.type) {
|
|
|
case 'offer':
|
|
|
this._updateSignalingState('have-local-offer');
|
|
|
break;
|
|
|
case 'answer':
|
|
|
this._updateSignalingState('stable');
|
|
|
break;
|
|
|
default:
|
|
|
throw new TypeError('unsupported type "' + description.type +
|
|
|
'"');
|
|
|
}
|
|
|
|
|
|
// If a success callback was provided, emit ICE candidates after it
|
|
|
// has been executed. Otherwise, emit callback after the Promise is
|
|
|
// resolved.
|
|
|
var hasCallback = arguments.length > 1 &&
|
|
|
typeof arguments[1] === 'function';
|
|
|
if (hasCallback) {
|
|
|
var cb = arguments[1];
|
|
|
window.setTimeout(function() {
|
|
|
cb();
|
|
|
if (self.iceGatheringState === 'new') {
|
|
|
self.iceGatheringState = 'gathering';
|
|
|
}
|
|
|
self._emitBufferedCandidates();
|
|
|
}, 0);
|
|
|
}
|
|
|
var p = Promise.resolve();
|
|
|
p.then(function() {
|
|
|
if (!hasCallback) {
|
|
|
if (self.iceGatheringState === 'new') {
|
|
|
self.iceGatheringState = 'gathering';
|
|
|
}
|
|
|
// Usually candidates will be emitted earlier.
|
|
|
window.setTimeout(self._emitBufferedCandidates.bind(self), 500);
|
|
|
}
|
|
|
});
|
|
|
return p;
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.setRemoteDescription =
|
|
|
function(description) {
|
|
|
var self = this;
|
|
|
var stream = new MediaStream();
|
|
|
var receiverList = [];
|
|
|
var sections = SDPUtils.splitSections(description.sdp);
|
|
|
var sessionpart = sections.shift();
|
|
|
var isIceLite = SDPUtils.matchPrefix(sessionpart,
|
|
|
'a=ice-lite').length > 0;
|
|
|
this.usingBundle = SDPUtils.matchPrefix(sessionpart,
|
|
|
'a=group:BUNDLE ').length > 0;
|
|
|
sections.forEach(function(mediaSection, sdpMLineIndex) {
|
|
|
var lines = SDPUtils.splitLines(mediaSection);
|
|
|
var mline = lines[0].substr(2).split(' ');
|
|
|
var kind = mline[0];
|
|
|
var rejected = mline[1] === '0';
|
|
|
var direction = SDPUtils.getDirection(mediaSection, sessionpart);
|
|
|
|
|
|
var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:');
|
|
|
if (mid.length) {
|
|
|
mid = mid[0].substr(6);
|
|
|
} else {
|
|
|
mid = SDPUtils.generateIdentifier();
|
|
|
}
|
|
|
|
|
|
// Reject datachannels which are not implemented yet.
|
|
|
if (kind === 'application' && mline[2] === 'DTLS/SCTP') {
|
|
|
self.transceivers[sdpMLineIndex] = {
|
|
|
mid: mid,
|
|
|
isDatachannel: true
|
|
|
};
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
var transceiver;
|
|
|
var iceGatherer;
|
|
|
var iceTransport;
|
|
|
var dtlsTransport;
|
|
|
var rtpSender;
|
|
|
var rtpReceiver;
|
|
|
var sendEncodingParameters;
|
|
|
var recvEncodingParameters;
|
|
|
var localCapabilities;
|
|
|
|
|
|
var track;
|
|
|
// FIXME: ensure the mediaSection has rtcp-mux set.
|
|
|
var remoteCapabilities = SDPUtils.parseRtpParameters(mediaSection);
|
|
|
var remoteIceParameters;
|
|
|
var remoteDtlsParameters;
|
|
|
if (!rejected) {
|
|
|
remoteIceParameters = SDPUtils.getIceParameters(mediaSection,
|
|
|
sessionpart);
|
|
|
remoteDtlsParameters = SDPUtils.getDtlsParameters(mediaSection,
|
|
|
sessionpart);
|
|
|
remoteDtlsParameters.role = 'client';
|
|
|
}
|
|
|
recvEncodingParameters =
|
|
|
SDPUtils.parseRtpEncodingParameters(mediaSection);
|
|
|
|
|
|
var cname;
|
|
|
// Gets the first SSRC. Note that with RTX there might be multiple
|
|
|
// SSRCs.
|
|
|
var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
|
|
|
.map(function(line) {
|
|
|
return SDPUtils.parseSsrcMedia(line);
|
|
|
})
|
|
|
.filter(function(obj) {
|
|
|
return obj.attribute === 'cname';
|
|
|
})[0];
|
|
|
if (remoteSsrc) {
|
|
|
cname = remoteSsrc.value;
|
|
|
}
|
|
|
|
|
|
var isComplete = SDPUtils.matchPrefix(mediaSection,
|
|
|
'a=end-of-candidates', sessionpart).length > 0;
|
|
|
var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')
|
|
|
.map(function(cand) {
|
|
|
return SDPUtils.parseCandidate(cand);
|
|
|
})
|
|
|
.filter(function(cand) {
|
|
|
return cand.component === '1';
|
|
|
});
|
|
|
if (description.type === 'offer' && !rejected) {
|
|
|
var transports = self.usingBundle && sdpMLineIndex > 0 ? {
|
|
|
iceGatherer: self.transceivers[0].iceGatherer,
|
|
|
iceTransport: self.transceivers[0].iceTransport,
|
|
|
dtlsTransport: self.transceivers[0].dtlsTransport
|
|
|
} : self._createIceAndDtlsTransports(mid, sdpMLineIndex);
|
|
|
|
|
|
if (isComplete) {
|
|
|
transports.iceTransport.setRemoteCandidates(cands);
|
|
|
}
|
|
|
|
|
|
localCapabilities = RTCRtpReceiver.getCapabilities(kind);
|
|
|
|
|
|
// filter RTX until additional stuff needed for RTX is implemented
|
|
|
// in adapter.js
|
|
|
localCapabilities.codecs = localCapabilities.codecs.filter(
|
|
|
function(codec) {
|
|
|
return codec.name !== 'rtx';
|
|
|
});
|
|
|
|
|
|
sendEncodingParameters = [{
|
|
|
ssrc: (2 * sdpMLineIndex + 2) * 1001
|
|
|
}];
|
|
|
|
|
|
rtpReceiver = new RTCRtpReceiver(transports.dtlsTransport, kind);
|
|
|
|
|
|
track = rtpReceiver.track;
|
|
|
receiverList.push([track, rtpReceiver]);
|
|
|
// FIXME: not correct when there are multiple streams but that is
|
|
|
// not currently supported in this shim.
|
|
|
stream.addTrack(track);
|
|
|
|
|
|
// FIXME: look at direction.
|
|
|
if (self.localStreams.length > 0 &&
|
|
|
self.localStreams[0].getTracks().length >= sdpMLineIndex) {
|
|
|
var localTrack;
|
|
|
if (kind === 'audio') {
|
|
|
localTrack = self.localStreams[0].getAudioTracks()[0];
|
|
|
} else if (kind === 'video') {
|
|
|
localTrack = self.localStreams[0].getVideoTracks()[0];
|
|
|
}
|
|
|
if (localTrack) {
|
|
|
rtpSender = new RTCRtpSender(localTrack,
|
|
|
transports.dtlsTransport);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
self.transceivers[sdpMLineIndex] = {
|
|
|
iceGatherer: transports.iceGatherer,
|
|
|
iceTransport: transports.iceTransport,
|
|
|
dtlsTransport: transports.dtlsTransport,
|
|
|
localCapabilities: localCapabilities,
|
|
|
remoteCapabilities: remoteCapabilities,
|
|
|
rtpSender: rtpSender,
|
|
|
rtpReceiver: rtpReceiver,
|
|
|
kind: kind,
|
|
|
mid: mid,
|
|
|
cname: cname,
|
|
|
sendEncodingParameters: sendEncodingParameters,
|
|
|
recvEncodingParameters: recvEncodingParameters
|
|
|
};
|
|
|
// Start the RTCRtpReceiver now. The RTPSender is started in
|
|
|
// setLocalDescription.
|
|
|
self._transceive(self.transceivers[sdpMLineIndex],
|
|
|
false,
|
|
|
direction === 'sendrecv' || direction === 'sendonly');
|
|
|
} else if (description.type === 'answer' && !rejected) {
|
|
|
transceiver = self.transceivers[sdpMLineIndex];
|
|
|
iceGatherer = transceiver.iceGatherer;
|
|
|
iceTransport = transceiver.iceTransport;
|
|
|
dtlsTransport = transceiver.dtlsTransport;
|
|
|
rtpSender = transceiver.rtpSender;
|
|
|
rtpReceiver = transceiver.rtpReceiver;
|
|
|
sendEncodingParameters = transceiver.sendEncodingParameters;
|
|
|
localCapabilities = transceiver.localCapabilities;
|
|
|
|
|
|
self.transceivers[sdpMLineIndex].recvEncodingParameters =
|
|
|
recvEncodingParameters;
|
|
|
self.transceivers[sdpMLineIndex].remoteCapabilities =
|
|
|
remoteCapabilities;
|
|
|
self.transceivers[sdpMLineIndex].cname = cname;
|
|
|
|
|
|
if ((isIceLite || isComplete) && cands.length) {
|
|
|
iceTransport.setRemoteCandidates(cands);
|
|
|
}
|
|
|
if (!self.usingBundle || sdpMLineIndex === 0) {
|
|
|
iceTransport.start(iceGatherer, remoteIceParameters,
|
|
|
'controlling');
|
|
|
dtlsTransport.start(remoteDtlsParameters);
|
|
|
}
|
|
|
|
|
|
self._transceive(transceiver,
|
|
|
direction === 'sendrecv' || direction === 'recvonly',
|
|
|
direction === 'sendrecv' || direction === 'sendonly');
|
|
|
|
|
|
if (rtpReceiver &&
|
|
|
(direction === 'sendrecv' || direction === 'sendonly')) {
|
|
|
track = rtpReceiver.track;
|
|
|
receiverList.push([track, rtpReceiver]);
|
|
|
stream.addTrack(track);
|
|
|
} else {
|
|
|
// FIXME: actually the receiver should be created later.
|
|
|
delete transceiver.rtpReceiver;
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
this.remoteDescription = {
|
|
|
type: description.type,
|
|
|
sdp: description.sdp
|
|
|
};
|
|
|
switch (description.type) {
|
|
|
case 'offer':
|
|
|
this._updateSignalingState('have-remote-offer');
|
|
|
break;
|
|
|
case 'answer':
|
|
|
this._updateSignalingState('stable');
|
|
|
break;
|
|
|
default:
|
|
|
throw new TypeError('unsupported type "' + description.type +
|
|
|
'"');
|
|
|
}
|
|
|
if (stream.getTracks().length) {
|
|
|
self.remoteStreams.push(stream);
|
|
|
window.setTimeout(function() {
|
|
|
var event = new Event('addstream');
|
|
|
event.stream = stream;
|
|
|
self.dispatchEvent(event);
|
|
|
if (self.onaddstream !== null) {
|
|
|
window.setTimeout(function() {
|
|
|
self.onaddstream(event);
|
|
|
}, 0);
|
|
|
}
|
|
|
|
|
|
receiverList.forEach(function(item) {
|
|
|
var track = item[0];
|
|
|
var receiver = item[1];
|
|
|
var trackEvent = new Event('track');
|
|
|
trackEvent.track = track;
|
|
|
trackEvent.receiver = receiver;
|
|
|
trackEvent.streams = [stream];
|
|
|
self.dispatchEvent(event);
|
|
|
if (self.ontrack !== null) {
|
|
|
window.setTimeout(function() {
|
|
|
self.ontrack(trackEvent);
|
|
|
}, 0);
|
|
|
}
|
|
|
});
|
|
|
}, 0);
|
|
|
}
|
|
|
if (arguments.length > 1 && typeof arguments[1] === 'function') {
|
|
|
window.setTimeout(arguments[1], 0);
|
|
|
}
|
|
|
return Promise.resolve();
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.close = function() {
|
|
|
this.transceivers.forEach(function(transceiver) {
|
|
|
/* not yet
|
|
|
if (transceiver.iceGatherer) {
|
|
|
transceiver.iceGatherer.close();
|
|
|
}
|
|
|
*/
|
|
|
if (transceiver.iceTransport) {
|
|
|
transceiver.iceTransport.stop();
|
|
|
}
|
|
|
if (transceiver.dtlsTransport) {
|
|
|
transceiver.dtlsTransport.stop();
|
|
|
}
|
|
|
if (transceiver.rtpSender) {
|
|
|
transceiver.rtpSender.stop();
|
|
|
}
|
|
|
if (transceiver.rtpReceiver) {
|
|
|
transceiver.rtpReceiver.stop();
|
|
|
}
|
|
|
});
|
|
|
// FIXME: clean up tracks, local streams, remote streams, etc
|
|
|
this._updateSignalingState('closed');
|
|
|
};
|
|
|
|
|
|
// Update the signaling state.
|
|
|
window.RTCPeerConnection.prototype._updateSignalingState =
|
|
|
function(newState) {
|
|
|
this.signalingState = newState;
|
|
|
var event = new Event('signalingstatechange');
|
|
|
this.dispatchEvent(event);
|
|
|
if (this.onsignalingstatechange !== null) {
|
|
|
this.onsignalingstatechange(event);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// Determine whether to fire the negotiationneeded event.
|
|
|
window.RTCPeerConnection.prototype._maybeFireNegotiationNeeded =
|
|
|
function() {
|
|
|
// Fire away (for now).
|
|
|
var event = new Event('negotiationneeded');
|
|
|
this.dispatchEvent(event);
|
|
|
if (this.onnegotiationneeded !== null) {
|
|
|
this.onnegotiationneeded(event);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// Update the connection state.
|
|
|
window.RTCPeerConnection.prototype._updateConnectionState = function() {
|
|
|
var self = this;
|
|
|
var newState;
|
|
|
var states = {
|
|
|
'new': 0,
|
|
|
closed: 0,
|
|
|
connecting: 0,
|
|
|
checking: 0,
|
|
|
connected: 0,
|
|
|
completed: 0,
|
|
|
failed: 0
|
|
|
};
|
|
|
this.transceivers.forEach(function(transceiver) {
|
|
|
states[transceiver.iceTransport.state]++;
|
|
|
states[transceiver.dtlsTransport.state]++;
|
|
|
});
|
|
|
// ICETransport.completed and connected are the same for this purpose.
|
|
|
states.connected += states.completed;
|
|
|
|
|
|
newState = 'new';
|
|
|
if (states.failed > 0) {
|
|
|
newState = 'failed';
|
|
|
} else if (states.connecting > 0 || states.checking > 0) {
|
|
|
newState = 'connecting';
|
|
|
} else if (states.disconnected > 0) {
|
|
|
newState = 'disconnected';
|
|
|
} else if (states.new > 0) {
|
|
|
newState = 'new';
|
|
|
} else if (states.connected > 0 || states.completed > 0) {
|
|
|
newState = 'connected';
|
|
|
}
|
|
|
|
|
|
if (newState !== self.iceConnectionState) {
|
|
|
self.iceConnectionState = newState;
|
|
|
var event = new Event('iceconnectionstatechange');
|
|
|
this.dispatchEvent(event);
|
|
|
if (this.oniceconnectionstatechange !== null) {
|
|
|
this.oniceconnectionstatechange(event);
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.createOffer = function() {
|
|
|
var self = this;
|
|
|
if (this._pendingOffer) {
|
|
|
throw new Error('createOffer called while there is a pending offer.');
|
|
|
}
|
|
|
var offerOptions;
|
|
|
if (arguments.length === 1 && typeof arguments[0] !== 'function') {
|
|
|
offerOptions = arguments[0];
|
|
|
} else if (arguments.length === 3) {
|
|
|
offerOptions = arguments[2];
|
|
|
}
|
|
|
|
|
|
var tracks = [];
|
|
|
var numAudioTracks = 0;
|
|
|
var numVideoTracks = 0;
|
|
|
// Default to sendrecv.
|
|
|
if (this.localStreams.length) {
|
|
|
numAudioTracks = this.localStreams[0].getAudioTracks().length;
|
|
|
numVideoTracks = this.localStreams[0].getVideoTracks().length;
|
|
|
}
|
|
|
// Determine number of audio and video tracks we need to send/recv.
|
|
|
if (offerOptions) {
|
|
|
// Reject Chrome legacy constraints.
|
|
|
if (offerOptions.mandatory || offerOptions.optional) {
|
|
|
throw new TypeError(
|
|
|
'Legacy mandatory/optional constraints not supported.');
|
|
|
}
|
|
|
if (offerOptions.offerToReceiveAudio !== undefined) {
|
|
|
numAudioTracks = offerOptions.offerToReceiveAudio;
|
|
|
}
|
|
|
if (offerOptions.offerToReceiveVideo !== undefined) {
|
|
|
numVideoTracks = offerOptions.offerToReceiveVideo;
|
|
|
}
|
|
|
}
|
|
|
if (this.localStreams.length) {
|
|
|
// Push local streams.
|
|
|
this.localStreams[0].getTracks().forEach(function(track) {
|
|
|
tracks.push({
|
|
|
kind: track.kind,
|
|
|
track: track,
|
|
|
wantReceive: track.kind === 'audio' ?
|
|
|
numAudioTracks > 0 : numVideoTracks > 0
|
|
|
});
|
|
|
if (track.kind === 'audio') {
|
|
|
numAudioTracks--;
|
|
|
} else if (track.kind === 'video') {
|
|
|
numVideoTracks--;
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
// Create M-lines for recvonly streams.
|
|
|
while (numAudioTracks > 0 || numVideoTracks > 0) {
|
|
|
if (numAudioTracks > 0) {
|
|
|
tracks.push({
|
|
|
kind: 'audio',
|
|
|
wantReceive: true
|
|
|
});
|
|
|
numAudioTracks--;
|
|
|
}
|
|
|
if (numVideoTracks > 0) {
|
|
|
tracks.push({
|
|
|
kind: 'video',
|
|
|
wantReceive: true
|
|
|
});
|
|
|
numVideoTracks--;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
var sdp = SDPUtils.writeSessionBoilerplate();
|
|
|
var transceivers = [];
|
|
|
tracks.forEach(function(mline, sdpMLineIndex) {
|
|
|
// For each track, create an ice gatherer, ice transport,
|
|
|
// dtls transport, potentially rtpsender and rtpreceiver.
|
|
|
var track = mline.track;
|
|
|
var kind = mline.kind;
|
|
|
var mid = SDPUtils.generateIdentifier();
|
|
|
|
|
|
var transports = self.usingBundle && sdpMLineIndex > 0 ? {
|
|
|
iceGatherer: transceivers[0].iceGatherer,
|
|
|
iceTransport: transceivers[0].iceTransport,
|
|
|
dtlsTransport: transceivers[0].dtlsTransport
|
|
|
} : self._createIceAndDtlsTransports(mid, sdpMLineIndex);
|
|
|
|
|
|
var localCapabilities = RTCRtpSender.getCapabilities(kind);
|
|
|
// filter RTX until additional stuff needed for RTX is implemented
|
|
|
// in adapter.js
|
|
|
localCapabilities.codecs = localCapabilities.codecs.filter(
|
|
|
function(codec) {
|
|
|
return codec.name !== 'rtx';
|
|
|
});
|
|
|
localCapabilities.codecs.forEach(function(codec) {
|
|
|
// work around https://bugs.chromium.org/p/webrtc/issues/detail?id=6552
|
|
|
// by adding level-asymmetry-allowed=1
|
|
|
if (codec.name === 'H264' &&
|
|
|
codec.parameters['level-asymmetry-allowed'] === undefined) {
|
|
|
codec.parameters['level-asymmetry-allowed'] = '1';
|
|
|
}
|
|
|
});
|
|
|
|
|
|
var rtpSender;
|
|
|
var rtpReceiver;
|
|
|
|
|
|
// generate an ssrc now, to be used later in rtpSender.send
|
|
|
var sendEncodingParameters = [{
|
|
|
ssrc: (2 * sdpMLineIndex + 1) * 1001
|
|
|
}];
|
|
|
if (track) {
|
|
|
rtpSender = new RTCRtpSender(track, transports.dtlsTransport);
|
|
|
}
|
|
|
|
|
|
if (mline.wantReceive) {
|
|
|
rtpReceiver = new RTCRtpReceiver(transports.dtlsTransport, kind);
|
|
|
}
|
|
|
|
|
|
transceivers[sdpMLineIndex] = {
|
|
|
iceGatherer: transports.iceGatherer,
|
|
|
iceTransport: transports.iceTransport,
|
|
|
dtlsTransport: transports.dtlsTransport,
|
|
|
localCapabilities: localCapabilities,
|
|
|
remoteCapabilities: null,
|
|
|
rtpSender: rtpSender,
|
|
|
rtpReceiver: rtpReceiver,
|
|
|
kind: kind,
|
|
|
mid: mid,
|
|
|
sendEncodingParameters: sendEncodingParameters,
|
|
|
recvEncodingParameters: null
|
|
|
};
|
|
|
});
|
|
|
if (this.usingBundle) {
|
|
|
sdp += 'a=group:BUNDLE ' + transceivers.map(function(t) {
|
|
|
return t.mid;
|
|
|
}).join(' ') + '\r\n';
|
|
|
}
|
|
|
tracks.forEach(function(mline, sdpMLineIndex) {
|
|
|
var transceiver = transceivers[sdpMLineIndex];
|
|
|
sdp += SDPUtils.writeMediaSection(transceiver,
|
|
|
transceiver.localCapabilities, 'offer', self.localStreams[0]);
|
|
|
});
|
|
|
|
|
|
this._pendingOffer = transceivers;
|
|
|
var desc = new RTCSessionDescription({
|
|
|
type: 'offer',
|
|
|
sdp: sdp
|
|
|
});
|
|
|
if (arguments.length && typeof arguments[0] === 'function') {
|
|
|
window.setTimeout(arguments[0], 0, desc);
|
|
|
}
|
|
|
return Promise.resolve(desc);
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.createAnswer = function() {
|
|
|
var self = this;
|
|
|
|
|
|
var sdp = SDPUtils.writeSessionBoilerplate();
|
|
|
if (this.usingBundle) {
|
|
|
sdp += 'a=group:BUNDLE ' + this.transceivers.map(function(t) {
|
|
|
return t.mid;
|
|
|
}).join(' ') + '\r\n';
|
|
|
}
|
|
|
this.transceivers.forEach(function(transceiver) {
|
|
|
if (transceiver.isDatachannel) {
|
|
|
sdp += 'm=application 0 DTLS/SCTP 5000\r\n' +
|
|
|
'c=IN IP4 0.0.0.0\r\n' +
|
|
|
'a=mid:' + transceiver.mid + '\r\n';
|
|
|
return;
|
|
|
}
|
|
|
// Calculate intersection of capabilities.
|
|
|
var commonCapabilities = self._getCommonCapabilities(
|
|
|
transceiver.localCapabilities,
|
|
|
transceiver.remoteCapabilities);
|
|
|
|
|
|
sdp += SDPUtils.writeMediaSection(transceiver, commonCapabilities,
|
|
|
'answer', self.localStreams[0]);
|
|
|
});
|
|
|
|
|
|
var desc = new RTCSessionDescription({
|
|
|
type: 'answer',
|
|
|
sdp: sdp
|
|
|
});
|
|
|
if (arguments.length && typeof arguments[0] === 'function') {
|
|
|
window.setTimeout(arguments[0], 0, desc);
|
|
|
}
|
|
|
return Promise.resolve(desc);
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.addIceCandidate = function(candidate) {
|
|
|
if (!candidate) {
|
|
|
this.transceivers.forEach(function(transceiver) {
|
|
|
transceiver.iceTransport.addRemoteCandidate({});
|
|
|
});
|
|
|
} else {
|
|
|
var mLineIndex = candidate.sdpMLineIndex;
|
|
|
if (candidate.sdpMid) {
|
|
|
for (var i = 0; i < this.transceivers.length; i++) {
|
|
|
if (this.transceivers[i].mid === candidate.sdpMid) {
|
|
|
mLineIndex = i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
var transceiver = this.transceivers[mLineIndex];
|
|
|
if (transceiver) {
|
|
|
var cand = Object.keys(candidate.candidate).length > 0 ?
|
|
|
SDPUtils.parseCandidate(candidate.candidate) : {};
|
|
|
// Ignore Chrome's invalid candidates since Edge does not like them.
|
|
|
if (cand.protocol === 'tcp' && (cand.port === 0 || cand.port === 9)) {
|
|
|
return;
|
|
|
}
|
|
|
// Ignore RTCP candidates, we assume RTCP-MUX.
|
|
|
if (cand.component !== '1') {
|
|
|
return;
|
|
|
}
|
|
|
// A dirty hack to make samples work.
|
|
|
if (cand.type === 'endOfCandidates') {
|
|
|
cand = {};
|
|
|
}
|
|
|
transceiver.iceTransport.addRemoteCandidate(cand);
|
|
|
|
|
|
// update the remoteDescription.
|
|
|
var sections = SDPUtils.splitSections(this.remoteDescription.sdp);
|
|
|
sections[mLineIndex + 1] += (cand.type ? candidate.candidate.trim()
|
|
|
: 'a=end-of-candidates') + '\r\n';
|
|
|
this.remoteDescription.sdp = sections.join('');
|
|
|
}
|
|
|
}
|
|
|
if (arguments.length > 1 && typeof arguments[1] === 'function') {
|
|
|
window.setTimeout(arguments[1], 0);
|
|
|
}
|
|
|
return Promise.resolve();
|
|
|
};
|
|
|
|
|
|
window.RTCPeerConnection.prototype.getStats = function() {
|
|
|
var promises = [];
|
|
|
this.transceivers.forEach(function(transceiver) {
|
|
|
['rtpSender', 'rtpReceiver', 'iceGatherer', 'iceTransport',
|
|
|
'dtlsTransport'].forEach(function(method) {
|
|
|
if (transceiver[method]) {
|
|
|
promises.push(transceiver[method].getStats());
|
|
|
}
|
|
|
});
|
|
|
});
|
|
|
var cb = arguments.length > 1 && typeof arguments[1] === 'function' &&
|
|
|
arguments[1];
|
|
|
return new Promise(function(resolve) {
|
|
|
// shim getStats with maplike support
|
|
|
var results = new Map();
|
|
|
Promise.all(promises).then(function(res) {
|
|
|
res.forEach(function(result) {
|
|
|
Object.keys(result).forEach(function(id) {
|
|
|
results.set(id, result[id]);
|
|
|
results[id] = result[id];
|
|
|
});
|
|
|
});
|
|
|
if (cb) {
|
|
|
window.setTimeout(cb, 0, results);
|
|
|
}
|
|
|
resolve(results);
|
|
|
});
|
|
|
});
|
|
|
};
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = {
|
|
|
shimPeerConnection: edgeShim.shimPeerConnection,
|
|
|
shimGetUserMedia: __webpack_require__(207)
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 207 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = function() {
|
|
|
var shimError_ = function(e) {
|
|
|
return {
|
|
|
name: {PermissionDeniedError: 'NotAllowedError'}[e.name] || e.name,
|
|
|
message: e.message,
|
|
|
constraint: e.constraint,
|
|
|
toString: function() {
|
|
|
return this.name;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
// getUserMedia error shim.
|
|
|
var origGetUserMedia = navigator.mediaDevices.getUserMedia.
|
|
|
bind(navigator.mediaDevices);
|
|
|
navigator.mediaDevices.getUserMedia = function(c) {
|
|
|
return origGetUserMedia(c).catch(function(e) {
|
|
|
return Promise.reject(shimError_(e));
|
|
|
});
|
|
|
};
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 208 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
var browserDetails = __webpack_require__(0).browserDetails;
|
|
|
|
|
|
var firefoxShim = {
|
|
|
shimOnTrack: function() {
|
|
|
if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
|
|
|
window.RTCPeerConnection.prototype)) {
|
|
|
Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
|
|
|
get: function() {
|
|
|
return this._ontrack;
|
|
|
},
|
|
|
set: function(f) {
|
|
|
if (this._ontrack) {
|
|
|
this.removeEventListener('track', this._ontrack);
|
|
|
this.removeEventListener('addstream', this._ontrackpoly);
|
|
|
}
|
|
|
this.addEventListener('track', this._ontrack = f);
|
|
|
this.addEventListener('addstream', this._ontrackpoly = function(e) {
|
|
|
e.stream.getTracks().forEach(function(track) {
|
|
|
var event = new Event('track');
|
|
|
event.track = track;
|
|
|
event.receiver = {track: track};
|
|
|
event.streams = [e.stream];
|
|
|
this.dispatchEvent(event);
|
|
|
}.bind(this));
|
|
|
}.bind(this));
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
},
|
|
|
|
|
|
shimSourceObject: function() {
|
|
|
// Firefox has supported mozSrcObject since FF22, unprefixed in 42.
|
|
|
if (typeof window === 'object') {
|
|
|
if (window.HTMLMediaElement &&
|
|
|
!('srcObject' in window.HTMLMediaElement.prototype)) {
|
|
|
// Shim the srcObject property, once, when HTMLMediaElement is found.
|
|
|
Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {
|
|
|
get: function() {
|
|
|
return this.mozSrcObject;
|
|
|
},
|
|
|
set: function(stream) {
|
|
|
this.mozSrcObject = stream;
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
|
|
|
shimPeerConnection: function() {
|
|
|
if (typeof window !== 'object' || !(window.RTCPeerConnection ||
|
|
|
window.mozRTCPeerConnection)) {
|
|
|
return; // probably media.peerconnection.enabled=false in about:config
|
|
|
}
|
|
|
// The RTCPeerConnection object.
|
|
|
if (!window.RTCPeerConnection) {
|
|
|
window.RTCPeerConnection = function(pcConfig, pcConstraints) {
|
|
|
if (browserDetails.version < 38) {
|
|
|
// .urls is not supported in FF < 38.
|
|
|
// create RTCIceServers with a single url.
|
|
|
if (pcConfig && pcConfig.iceServers) {
|
|
|
var newIceServers = [];
|
|
|
for (var i = 0; i < pcConfig.iceServers.length; i++) {
|
|
|
var server = pcConfig.iceServers[i];
|
|
|
if (server.hasOwnProperty('urls')) {
|
|
|
for (var j = 0; j < server.urls.length; j++) {
|
|
|
var newServer = {
|
|
|
url: server.urls[j]
|
|
|
};
|
|
|
if (server.urls[j].indexOf('turn') === 0) {
|
|
|
newServer.username = server.username;
|
|
|
newServer.credential = server.credential;
|
|
|
}
|
|
|
newIceServers.push(newServer);
|
|
|
}
|
|
|
} else {
|
|
|
newIceServers.push(pcConfig.iceServers[i]);
|
|
|
}
|
|
|
}
|
|
|
pcConfig.iceServers = newIceServers;
|
|
|
}
|
|
|
}
|
|
|
return new mozRTCPeerConnection(pcConfig, pcConstraints);
|
|
|
};
|
|
|
window.RTCPeerConnection.prototype = mozRTCPeerConnection.prototype;
|
|
|
|
|
|
// wrap static methods. Currently just generateCertificate.
|
|
|
if (mozRTCPeerConnection.generateCertificate) {
|
|
|
Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
|
|
|
get: function() {
|
|
|
return mozRTCPeerConnection.generateCertificate;
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
window.RTCSessionDescription = mozRTCSessionDescription;
|
|
|
window.RTCIceCandidate = mozRTCIceCandidate;
|
|
|
}
|
|
|
|
|
|
// shim away need for obsolete RTCIceCandidate/RTCSessionDescription.
|
|
|
['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
|
|
|
.forEach(function(method) {
|
|
|
var nativeMethod = RTCPeerConnection.prototype[method];
|
|
|
RTCPeerConnection.prototype[method] = function() {
|
|
|
arguments[0] = new ((method === 'addIceCandidate') ?
|
|
|
RTCIceCandidate : RTCSessionDescription)(arguments[0]);
|
|
|
return nativeMethod.apply(this, arguments);
|
|
|
};
|
|
|
});
|
|
|
|
|
|
// support for addIceCandidate(null or undefined)
|
|
|
var nativeAddIceCandidate =
|
|
|
RTCPeerConnection.prototype.addIceCandidate;
|
|
|
RTCPeerConnection.prototype.addIceCandidate = function() {
|
|
|
if (!arguments[0]) {
|
|
|
if (arguments[1]) {
|
|
|
arguments[1].apply(null);
|
|
|
}
|
|
|
return Promise.resolve();
|
|
|
}
|
|
|
return nativeAddIceCandidate.apply(this, arguments);
|
|
|
};
|
|
|
|
|
|
if (browserDetails.version < 48) {
|
|
|
// shim getStats with maplike support
|
|
|
var makeMapStats = function(stats) {
|
|
|
var map = new Map();
|
|
|
Object.keys(stats).forEach(function(key) {
|
|
|
map.set(key, stats[key]);
|
|
|
map[key] = stats[key];
|
|
|
});
|
|
|
return map;
|
|
|
};
|
|
|
|
|
|
var nativeGetStats = RTCPeerConnection.prototype.getStats;
|
|
|
RTCPeerConnection.prototype.getStats = function(selector, onSucc, onErr) {
|
|
|
return nativeGetStats.apply(this, [selector || null])
|
|
|
.then(function(stats) {
|
|
|
return makeMapStats(stats);
|
|
|
})
|
|
|
.then(onSucc, onErr);
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = {
|
|
|
shimOnTrack: firefoxShim.shimOnTrack,
|
|
|
shimSourceObject: firefoxShim.shimSourceObject,
|
|
|
shimPeerConnection: firefoxShim.shimPeerConnection,
|
|
|
shimGetUserMedia: __webpack_require__(209)
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 209 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
/* eslint-env node */
|
|
|
|
|
|
|
|
|
var logging = __webpack_require__(0).log;
|
|
|
var browserDetails = __webpack_require__(0).browserDetails;
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = function() {
|
|
|
var shimError_ = function(e) {
|
|
|
return {
|
|
|
name: {
|
|
|
SecurityError: 'NotAllowedError',
|
|
|
PermissionDeniedError: 'NotAllowedError'
|
|
|
}[e.name] || e.name,
|
|
|
message: {
|
|
|
'The operation is insecure.': 'The request is not allowed by the ' +
|
|
|
'user agent or the platform in the current context.'
|
|
|
}[e.message] || e.message,
|
|
|
constraint: e.constraint,
|
|
|
toString: function() {
|
|
|
return this.name + (this.message && ': ') + this.message;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
// getUserMedia constraints shim.
|
|
|
var getUserMedia_ = function(constraints, onSuccess, onError) {
|
|
|
var constraintsToFF37_ = function(c) {
|
|
|
if (typeof c !== 'object' || c.require) {
|
|
|
return c;
|
|
|
}
|
|
|
var require = [];
|
|
|
Object.keys(c).forEach(function(key) {
|
|
|
if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
|
|
|
return;
|
|
|
}
|
|
|
var r = c[key] = (typeof c[key] === 'object') ?
|
|
|
c[key] : {ideal: c[key]};
|
|
|
if (r.min !== undefined ||
|
|
|
r.max !== undefined || r.exact !== undefined) {
|
|
|
require.push(key);
|
|
|
}
|
|
|
if (r.exact !== undefined) {
|
|
|
if (typeof r.exact === 'number') {
|
|
|
r. min = r.max = r.exact;
|
|
|
} else {
|
|
|
c[key] = r.exact;
|
|
|
}
|
|
|
delete r.exact;
|
|
|
}
|
|
|
if (r.ideal !== undefined) {
|
|
|
c.advanced = c.advanced || [];
|
|
|
var oc = {};
|
|
|
if (typeof r.ideal === 'number') {
|
|
|
oc[key] = {min: r.ideal, max: r.ideal};
|
|
|
} else {
|
|
|
oc[key] = r.ideal;
|
|
|
}
|
|
|
c.advanced.push(oc);
|
|
|
delete r.ideal;
|
|
|
if (!Object.keys(r).length) {
|
|
|
delete c[key];
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
if (require.length) {
|
|
|
c.require = require;
|
|
|
}
|
|
|
return c;
|
|
|
};
|
|
|
constraints = JSON.parse(JSON.stringify(constraints));
|
|
|
if (browserDetails.version < 38) {
|
|
|
logging('spec: ' + JSON.stringify(constraints));
|
|
|
if (constraints.audio) {
|
|
|
constraints.audio = constraintsToFF37_(constraints.audio);
|
|
|
}
|
|
|
if (constraints.video) {
|
|
|
constraints.video = constraintsToFF37_(constraints.video);
|
|
|
}
|
|
|
logging('ff37: ' + JSON.stringify(constraints));
|
|
|
}
|
|
|
return navigator.mozGetUserMedia(constraints, onSuccess, function(e) {
|
|
|
onError(shimError_(e));
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// Returns the result of getUserMedia as a Promise.
|
|
|
var getUserMediaPromise_ = function(constraints) {
|
|
|
return new Promise(function(resolve, reject) {
|
|
|
getUserMedia_(constraints, resolve, reject);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// Shim for mediaDevices on older versions.
|
|
|
if (!navigator.mediaDevices) {
|
|
|
navigator.mediaDevices = {getUserMedia: getUserMediaPromise_,
|
|
|
addEventListener: function() { },
|
|
|
removeEventListener: function() { }
|
|
|
};
|
|
|
}
|
|
|
navigator.mediaDevices.enumerateDevices =
|
|
|
navigator.mediaDevices.enumerateDevices || function() {
|
|
|
return new Promise(function(resolve) {
|
|
|
var infos = [
|
|
|
{kind: 'audioinput', deviceId: 'default', label: '', groupId: ''},
|
|
|
{kind: 'videoinput', deviceId: 'default', label: '', groupId: ''}
|
|
|
];
|
|
|
resolve(infos);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
if (browserDetails.version < 41) {
|
|
|
// Work around http://bugzil.la/1169665
|
|
|
var orgEnumerateDevices =
|
|
|
navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
|
|
|
navigator.mediaDevices.enumerateDevices = function() {
|
|
|
return orgEnumerateDevices().then(undefined, function(e) {
|
|
|
if (e.name === 'NotFoundError') {
|
|
|
return [];
|
|
|
}
|
|
|
throw e;
|
|
|
});
|
|
|
};
|
|
|
}
|
|
|
if (browserDetails.version < 49) {
|
|
|
var origGetUserMedia = navigator.mediaDevices.getUserMedia.
|
|
|
bind(navigator.mediaDevices);
|
|
|
navigator.mediaDevices.getUserMedia = function(c) {
|
|
|
return origGetUserMedia(c).then(function(stream) {
|
|
|
// Work around https://bugzil.la/802326
|
|
|
if (c.audio && !stream.getAudioTracks().length ||
|
|
|
c.video && !stream.getVideoTracks().length) {
|
|
|
stream.getTracks().forEach(function(track) {
|
|
|
track.stop();
|
|
|
});
|
|
|
throw new DOMException('The object can not be found here.',
|
|
|
'NotFoundError');
|
|
|
}
|
|
|
return stream;
|
|
|
}, function(e) {
|
|
|
return Promise.reject(shimError_(e));
|
|
|
});
|
|
|
};
|
|
|
}
|
|
|
navigator.getUserMedia = function(constraints, onSuccess, onError) {
|
|
|
if (browserDetails.version < 44) {
|
|
|
return getUserMedia_(constraints, onSuccess, onError);
|
|
|
}
|
|
|
// Replace Firefox 44+'s deprecation warning with unprefixed version.
|
|
|
console.warn('navigator.getUserMedia has been replaced by ' +
|
|
|
'navigator.mediaDevices.getUserMedia');
|
|
|
navigator.mediaDevices.getUserMedia(constraints).then(onSuccess, onError);
|
|
|
};
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 210 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/*
|
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
|
*
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
* tree.
|
|
|
*/
|
|
|
|
|
|
var safariShim = {
|
|
|
// TODO: DrAlex, should be here, double check against LayoutTests
|
|
|
// shimOnTrack: function() { },
|
|
|
|
|
|
// TODO: once the back-end for the mac port is done, add.
|
|
|
// TODO: check for webkitGTK+
|
|
|
// shimPeerConnection: function() { },
|
|
|
|
|
|
shimGetUserMedia: function() {
|
|
|
navigator.getUserMedia = navigator.webkitGetUserMedia;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// Expose public methods.
|
|
|
module.exports = {
|
|
|
shimGetUserMedia: safariShim.shimGetUserMedia
|
|
|
// TODO
|
|
|
// shimOnTrack: safariShim.shimOnTrack,
|
|
|
// shimPeerConnection: safariShim.shimPeerConnection
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 211 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_211__;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 212 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_212__;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 213 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_213__;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 214 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
module.exports = __webpack_require__(71);
|
|
|
|
|
|
|
|
|
/***/ })
|
|
|
/******/ ]);
|
|
|
});
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap 4c48b12438da9b36927e","webpack:///./~/webrtc-adapter/src/js/utils.js","webpack:///./~/lodash/_root.js","webpack:///./~/lodash/isArray.js","webpack:///./~/lodash/isObject.js","webpack:///./~/lodash/_getNative.js","webpack:///./src/reader/ean_reader.js","webpack:///./~/lodash/_baseGetTag.js","webpack:///./~/lodash/_castPath.js","webpack:///./~/lodash/_copyObject.js","webpack:///./~/lodash/isObjectLike.js","webpack:///./src/reader/barcode_reader.js","webpack:///./~/gl-vec2/clone.js","webpack:///./~/lodash/_Symbol.js","webpack:///./src/common/array_helper.js","webpack:///./src/common/image_debug.js","webpack:///./~/lodash/_ListCache.js","webpack:///./~/lodash/_assocIndexOf.js","webpack:///./~/lodash/_getMapData.js","webpack:///./~/lodash/_isIndex.js","webpack:///./~/lodash/_nativeCreate.js","webpack:///./~/lodash/_toKey.js","webpack:///./~/lodash/eq.js","webpack:///./~/lodash/isArguments.js","webpack:///./~/lodash/isArrayLike.js","webpack:///./~/lodash/keysIn.js","webpack:///./src/common/cv_utils.js","webpack:///./src/common/image_wrapper.js","webpack:///./~/lodash/_Map.js","webpack:///./~/lodash/_arrayPush.js","webpack:///./~/lodash/_assignValue.js","webpack:///./~/lodash/_baseAssignValue.js","webpack:///./~/lodash/_cloneArrayBuffer.js","webpack:///./~/lodash/_getPrototype.js","webpack:///./~/lodash/_getSymbols.js","webpack:///./~/lodash/_isPrototype.js","webpack:///./~/lodash/isBuffer.js","webpack:///./~/lodash/isFunction.js","webpack:///./~/lodash/isLength.js","webpack:///./~/lodash/isSymbol.js","webpack:///./~/lodash/keys.js","webpack:///./~/lodash/merge.js","webpack:///(webpack)/buildin/module.js","webpack:///./src/locator/tracer.js","webpack:///./src/reader/code_39_reader.js","webpack:///./~/gl-vec2/dot.js","webpack:///./~/lodash/_MapCache.js","webpack:///./~/lodash/_Stack.js","webpack:///./~/lodash/_arrayLikeKeys.js","webpack:///./~/lodash/_arrayMap.js","webpack:///./~/lodash/_arrayReduce.js","webpack:///./~/lodash/_assignMergeValue.js","webpack:///./~/lodash/_baseGet.js","webpack:///./~/lodash/_baseGetAllKeys.js","webpack:///./~/lodash/_cloneBuffer.js","webpack:///./~/lodash/_cloneTypedArray.js","webpack:///./~/lodash/_copyArray.js","webpack:///./~/lodash/_defineProperty.js","webpack:///./~/lodash/_flatRest.js","webpack:///./~/lodash/_freeGlobal.js","webpack:///./~/lodash/_getAllKeysIn.js","webpack:///./~/lodash/_getSymbolsIn.js","webpack:///./~/lodash/_initCloneObject.js","webpack:///./~/lodash/_overArg.js","webpack:///./~/lodash/_overRest.js","webpack:///./~/lodash/_setToString.js","webpack:///./~/lodash/_toSource.js","webpack:///./~/lodash/identity.js","webpack:///./~/lodash/isPlainObject.js","webpack:///./~/lodash/isTypedArray.js","webpack:///./~/lodash/stubArray.js","webpack:///(webpack)/buildin/global.js","webpack:///./src/quagga.js","webpack:///./lib/frame_grabber.js","webpack:///./lib/input_stream.js","webpack:///./src/analytics/result_collector.js","webpack:///./src/common/cluster.js","webpack:///./src/common/events.js","webpack:///./src/common/mediaDevices.js","webpack:///./src/common/subImage.js","webpack:///./src/common/typedefs.js","webpack:///./src/config/config.js","webpack:///./src/config/config.node.js","webpack:///./src/decoder/barcode_decoder.js","webpack:///./src/decoder/bresenham.js","webpack:///./src/input/camera_access.js","webpack:///./src/locator/barcode_locator.js","webpack:///./src/locator/rasterizer.js","webpack:///./src/locator/skeletonizer.js","webpack:///./src/reader/codabar_reader.js","webpack:///./src/reader/code_128_reader.js","webpack:///./src/reader/code_39_vin_reader.js","webpack:///./src/reader/ean_2_reader.js","webpack:///./src/reader/ean_5_reader.js","webpack:///./src/reader/ean_8_reader.js","webpack:///./src/reader/i2of5_reader.js","webpack:///./src/reader/upc_e_reader.js","webpack:///./src/reader/upc_reader.js","webpack:///./~/gl-mat2/copy.js","webpack:///./~/gl-mat2/create.js","webpack:///./~/gl-mat2/invert.js","webpack:///./~/gl-vec2/scale.js","webpack:///./~/gl-vec2/transformMat2.js","webpack:///./~/gl-vec3/clone.js","webpack:///./~/lodash/_DataView.js","webpack:///./~/lodash/_Hash.js","webpack:///./~/lodash/_Promise.js","webpack:///./~/lodash/_Set.js","webpack:///./~/lodash/_Uint8Array.js","webpack:///./~/lodash/_WeakMap.js","webpack:///./~/lodash/_addMapEntry.js","webpack:///./~/lodash/_addSetEntry.js","webpack:///./~/lodash/_apply.js","webpack:///./~/lodash/_arrayEach.js","webpack:///./~/lodash/_arrayFilter.js","webpack:///./~/lodash/_baseAssign.js","webpack:///./~/lodash/_baseAssignIn.js","webpack:///./~/lodash/_baseClone.js","webpack:///./~/lodash/_baseCreate.js","webpack:///./~/lodash/_baseFlatten.js","webpack:///./~/lodash/_baseFor.js","webpack:///./~/lodash/_baseHasIn.js","webpack:///./~/lodash/_baseIsArguments.js","webpack:///./~/lodash/_baseIsNative.js","webpack:///./~/lodash/_baseIsTypedArray.js","webpack:///./~/lodash/_baseKeys.js","webpack:///./~/lodash/_baseKeysIn.js","webpack:///./~/lodash/_baseMerge.js","webpack:///./~/lodash/_baseMergeDeep.js","webpack:///./~/lodash/_basePick.js","webpack:///./~/lodash/_basePickBy.js","webpack:///./~/lodash/_baseRest.js","webpack:///./~/lodash/_baseSet.js","webpack:///./~/lodash/_baseSetToString.js","webpack:///./~/lodash/_baseSlice.js","webpack:///./~/lodash/_baseTimes.js","webpack:///./~/lodash/_baseToString.js","webpack:///./~/lodash/_baseUnary.js","webpack:///./~/lodash/_baseUnset.js","webpack:///./~/lodash/_cloneDataView.js","webpack:///./~/lodash/_cloneMap.js","webpack:///./~/lodash/_cloneRegExp.js","webpack:///./~/lodash/_cloneSet.js","webpack:///./~/lodash/_cloneSymbol.js","webpack:///./~/lodash/_copySymbols.js","webpack:///./~/lodash/_copySymbolsIn.js","webpack:///./~/lodash/_coreJsData.js","webpack:///./~/lodash/_createAssigner.js","webpack:///./~/lodash/_createBaseFor.js","webpack:///./~/lodash/_customOmitClone.js","webpack:///./~/lodash/_getAllKeys.js","webpack:///./~/lodash/_getRawTag.js","webpack:///./~/lodash/_getTag.js","webpack:///./~/lodash/_getValue.js","webpack:///./~/lodash/_hasPath.js","webpack:///./~/lodash/_hashClear.js","webpack:///./~/lodash/_hashDelete.js","webpack:///./~/lodash/_hashGet.js","webpack:///./~/lodash/_hashHas.js","webpack:///./~/lodash/_hashSet.js","webpack:///./~/lodash/_initCloneArray.js","webpack:///./~/lodash/_initCloneByTag.js","webpack:///./~/lodash/_isFlattenable.js","webpack:///./~/lodash/_isIterateeCall.js","webpack:///./~/lodash/_isKey.js","webpack:///./~/lodash/_isKeyable.js","webpack:///./~/lodash/_isMasked.js","webpack:///./~/lodash/_listCacheClear.js","webpack:///./~/lodash/_listCacheDelete.js","webpack:///./~/lodash/_listCacheGet.js","webpack:///./~/lodash/_listCacheHas.js","webpack:///./~/lodash/_listCacheSet.js","webpack:///./~/lodash/_mapCacheClear.js","webpack:///./~/lodash/_mapCacheDelete.js","webpack:///./~/lodash/_mapCacheGet.js","webpack:///./~/lodash/_mapCacheHas.js","webpack:///./~/lodash/_mapCacheSet.js","webpack:///./~/lodash/_mapToArray.js","webpack:///./~/lodash/_memoizeCapped.js","webpack:///./~/lodash/_nativeKeys.js","webpack:///./~/lodash/_nativeKeysIn.js","webpack:///./~/lodash/_nodeUtil.js","webpack:///./~/lodash/_objectToString.js","webpack:///./~/lodash/_parent.js","webpack:///./~/lodash/_setToArray.js","webpack:///./~/lodash/_shortOut.js","webpack:///./~/lodash/_stackClear.js","webpack:///./~/lodash/_stackDelete.js","webpack:///./~/lodash/_stackGet.js","webpack:///./~/lodash/_stackHas.js","webpack:///./~/lodash/_stackSet.js","webpack:///./~/lodash/_stringToPath.js","webpack:///./~/lodash/constant.js","webpack:///./~/lodash/flatten.js","webpack:///./~/lodash/hasIn.js","webpack:///./~/lodash/isArrayLikeObject.js","webpack:///./~/lodash/last.js","webpack:///./~/lodash/memoize.js","webpack:///./~/lodash/omit.js","webpack:///./~/lodash/pick.js","webpack:///./~/lodash/stubFalse.js","webpack:///./~/lodash/toPlainObject.js","webpack:///./~/lodash/toString.js","webpack:///./~/sdp/sdp.js","webpack:///./~/webrtc-adapter/src/js/adapter_core.js","webpack:///./~/webrtc-adapter/src/js/chrome/chrome_shim.js","webpack:///./~/webrtc-adapter/src/js/chrome/getusermedia.js","webpack:///./~/webrtc-adapter/src/js/edge/edge_shim.js","webpack:///./~/webrtc-adapter/src/js/edge/getusermedia.js","webpack:///./~/webrtc-adapter/src/js/firefox/firefox_shim.js","webpack:///./~/webrtc-adapter/src/js/firefox/getusermedia.js","webpack:///./~/webrtc-adapter/src/js/safari/safari_shim.js","webpack:///external \"get-pixels\"","webpack:///external \"ndarray\"","webpack:///external \"ndarray-linear-interpolate\""],"names":["EANReader","opts","supplements","getDefaulConfig","call","config","Object","keys","CONFIG_KEYS","forEach","key","default","properties","CODE_L_START","value","CODE_G_START","START_PATTERN","STOP_PATTERN","MIDDLE_PATTERN","EXTENSION_START_PATTERN","CODE_PATTERN","CODE_FREQUENCY","SINGLE_CODE_ERROR","AVG_CODE_ERROR","FORMAT","writeable","prototype","create","constructor","_decodeCode","start","coderange","counter","i","self","offset","isWhite","_row","counterPos","bestMatch","error","Number","MAX_VALUE","code","end","length","_matchPattern","_findPattern","pattern","tryHarder","epsilon","j","sum","_nextSet","undefined","_findStart","leadingWhitespaceStart","startInfo","_matchRange","_verifyTrailingWhitespace","endInfo","trailingWhitespaceEnd","_findEnd","_calculateFirstDigit","codeFrequency","_decodePayload","result","decodedCodes","firstDigit","push","unshift","_decode","resultInfo","_checksum","ext","_decodeExtensions","lastCode","supplement","join","codeset","decode","BarcodeReader","_nextUnset","line","maxSingleError","singleError","modulo","barWidth","count","scaled","Math","abs","_correctBars","correction","indices","tmp","_matchTrace","cmpCounter","decodePattern","reverse","direction","DIRECTION","REVERSE","FORWARD","format","_fillCounters","counters","defineProperty","Exception","StartNotFoundException","CodeNotFoundException","PatternNotFoundException","init","arr","val","l","shuffle","x","floor","random","toPointList","row","rows","threshold","scoreFunc","queue","apply","maxIndex","max","drawRect","pos","size","ctx","style","strokeStyle","color","fillStyle","lineWidth","beginPath","strokeRect","y","drawPath","path","def","moveTo","lineTo","closePath","stroke","drawImage","imageData","canvasData","getImageData","data","imageDataPos","canvasDataPos","putImageData","imageRef","computeIntegralImage2","computeIntegralImage","thresholdImage","computeHistogram","sharpenLine","determineOtsuThreshold","otsuThreshold","computeBinaryImage","cluster","dilate","erode","subtract","bitwiseOr","countNonZero","topGeneric","grayArrayFromImage","grayArrayFromContext","grayAndHalfSampleFromCanvasData","computeGray","loadImageArray","halfSample","hsv2rgb","_computeDivisors","calculatePatchSize","_parseCSSDimensionValues","computeImageArea","vec2","clone","require","vec3","that","toVec2","toVec3","round","imageWrapper","integralWrapper","width","height","integralImageData","posA","posB","posC","posD","v","u","targetWrapper","targetData","bitsPerPixel","bitShift","bucketCnt","hist","Int32Array","left","center","right","px","mx","determineThreshold","vet","p1","p2","p12","k","m1","m2","m12","kernel","A","B","C","D","avg","points","property","point","clusters","addToCluster","newPoint","found","fits","add","createPoint","Tracer","trace","vec","iteration","maxIterations","top","centerPos","currentPos","idx","forward","from","to","toIdx","predictedPos","thresholdX","thresholdY","match","predicted","DILATE","ERODE","inImageWrapper","outImageWrapper","inImageData","outImageData","yStart1","yStart2","xStart1","xStart2","aImageWrapper","bImageWrapper","resultImageWrapper","aImageData","bImageData","cImageData","list","minIdx","min","score","hit","item","htmlImage","offsetX","array","ctxData","outArray","topRowIdx","bottomRowIdx","endIdx","outWidth","outImgIdx","inWidth","singleChannel","src","callback","canvas","document","createElement","img","Image","onload","getContext","Uint8Array","inImgWrapper","outImgWrapper","inImg","outImg","hsv","rgb","h","s","c","m","r","g","b","n","largeDivisors","divisors","sqrt","concat","_computeIntersection","arr1","arr2","patchSize","imgSize","divisorsX","divisorsY","wideSide","common","nrOfPatchesList","nrOfPatchesMap","nrOfPatchesIdx","medium","nrOfPatches","desiredPatchSize","optimalPatchSize","findPatchSizeForDivisors","dimension","parseFloat","unit","indexOf","_dimensionsConverters","context","bottom","inputWidth","inputHeight","area","parsedArea","reduce","parsed","calculated","sx","sy","sw","sh","ImageWrapper","ArrayType","initialize","Array","inImageWithBorder","imgRef","border","sample","lx","ly","w","base","a","d","e","clearArray","subImage","subImageAsCopy","sizeY","sizeX","copyTo","srcData","dstData","get","getSafe","indexMapping","set","zeroBorder","invert","convolve","kx","ky","kSize","accu","moments","labelcount","ysq","labelsum","label","mu11","mu02","mu20","x_","y_","PI","PI_4","m00","m01","m10","m11","m02","m20","theta","rad","isNaN","atan","cos","sin","show","scale","frame","current","pixel","overlay","whiteRgb","blackRgb","searchDirections","labelWrapper","labelData","edgelabel","cy","dir","cx","vertex2D","next","prev","contourTracing","Fv","Cv","P","ldir","Code39Reader","ALPHABETH_STRING","ALPHABET","CHARACTER_ENCODINGS","ASTERISK","_toCounters","numCounters","decodedChar","lastStart","nextStart","_toPattern","_patternToChar","pop","patternSize","String","fromCharCode","_findNextWidth","minWidth","maxNarrowWidth","numWideBars","wideBarWidth","patternStart","whiteSpaceMustStart","_inputStream","_framegrabber","_stopped","_canvasContainer","image","dom","_inputImageWrapper","_boxSize","_decoder","_workerPool","_onUIThread","_resultCollector","_config","initializeData","initBuffers","decoder","initInputStream","cb","video","inputStream","type","createVideoStream","createImageStream","$viewport","getViewPort","querySelector","appendChild","createLiveStream","request","constraints","then","trigger","catch","err","setAttribute","setInputStream","addEventListener","canRecord","bind","target","nodeName","nodeType","selector","checkImageConstraints","locator","initCanvas","adjustWorkerPool","numOfWorkers","ready","play","className","getCanvasSize","clearFix","getWidth","getHeight","console","log","getBoundingBoxes","locate","transformResult","topRight","getTopRight","xOffset","yOffset","barcodes","moveLine","box","moveBox","boxes","corner","addResult","filter","barcode","codeResult","hasCodeResult","some","publishResult","resultToPublish","publish","locateAndDecode","decodeFromBoundingBoxes","update","availableWorker","workerThread","busy","attachData","grab","worker","postMessage","cmd","buffer","startContinuousUpdate","delay","frequency","timestamp","window","requestAnimFrame","performance","now","initWorker","blobURL","generateWorkerBlob","Worker","onmessage","event","URL","revokeObjectURL","message","configForWorker","workerInterface","factory","Quagga","onProcessed","setReaders","readers","blob","factorySource","__factorySource__","Blob","toString","createObjectURL","capacity","increaseBy","workersToTerminate","slice","terminate","workerInitialized","stop","release","clearEventHandlers","pause","onDetected","subscribe","offDetected","unsubscribe","offProcessed","registerResultCollector","resultCollector","decodeSingle","resultCallback","sequence","once","ImageDebug","ResultCollector","CameraAccess","CVUtils","Ndarray","Interp2D","d2","FrameGrabber","_that","_streamConfig","getConfig","_video_size","getRealWidth","getRealHeight","_canvasSize","_size","_topRight","_data","_grayData","_canvasData","_grayImageArray","transpose","_canvasImageArray","_targetImageArray","hi","lo","_stepSizeX","_stepSizeY","JSON","stringify","videoSize","shape","canvasSize","stepSize","getData","getFrame","scaleAndCrop","Error","getSize","module","exports","GetPixels","InputStream","frameIdx","paused","loaded","baseUrl","ended","calculatedWidth","calculatedHeight","_eventNames","_eventHandlers","loadImages","pixels","exit","setTimeout","publishEvent","eventName","args","handlers","setWidth","setHeight","stream","setCurrentTime","time","f","setTopRight","setCanvasSize","contains","every","passesFilter","results","capture","matchesConstraints","blacklist","imageSize","toDataURL","getResults","dot","pointMap","updateCenter","pointToAdd","id","otherPoint","similarity","getPoints","getCenter","events","getEvent","subscribers","clearEvents","publishSubscription","subscription","async","subscriber","enumerateDevices","getUserMedia","navigator","mediaDevices","Promise","reject","SubImage","I","originalSize","updateData","updateFrom","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","imul","ah","al","bh","bl","assign","TypeError","index","arguments","nextSource","nextKey","hasOwnProperty","READERS","code_128_reader","ean_reader","ean_5_reader","ean_2_reader","ean_8_reader","code_39_reader","code_39_vin_reader","codabar_reader","upc_reader","upc_e_reader","i2of5_reader","inputImageWrapper","_canvas","_barcodeReaders","initReaders","initConfig","$debug","readerConfig","reader","configuration","map","vis","node","prop","debug","showFrequency","showPattern","display","getExtendedLine","angle","extendLine","amount","extension","ceil","getLine","tryDecode","barcodeLine","getBarcodeLine","printFrequency","toBinaryLine","printPattern","tryDecodeBruteForce","lineAngle","sideLength","pow","slices","xdir","ydir","getLineLength","decodeFromBoundingBox","lineLength","drawBoundingBox","atan2","multiple","Bresenham","Slope","DIR","UP","DOWN","x0","y0","x1","y1","steep","deltax","deltay","ystep","read","slope","slope2","extrema","currentDir","rThreshold","fillColor","fillRect","pickConstraints","facingMatching","streamRef","waitForVideo","resolve","attempts","checkVideo","videoWidth","videoHeight","initCamera","srcObject","deprecatedConstraints","videoConstraints","normalized","minAspectRatio","aspectRatio","facing","facingMode","pickDevice","desiredFacing","facingMatch","selectedDeviceId","devices","device","kind","test","facingDevice","deviceId","normalizedConstraints","audio","enumerateVideoDevices","tracks","getVideoTracks","getActiveStreamLabel","transformMat2","mat2","copy","_currentImageWrapper","_skelImageWrapper","_subImageWrapper","_labelImageWrapper","_patchGrid","_patchLabelGrid","_imageToPatchGrid","_binaryImageWrapper","_patchSize","binary","_numPatches","_skeletonizer","skeletonImageData","ArrayBuffer","global","useWorker","boxFromPatches","patches","overAvg","patch","transMat","minx","miny","maxx","maxy","binarizeImage","findPatches","patchesFound","rasterizer","rasterResult","skeletonize","rasterize","describePatch","findBiggestConnectedAreas","maxLabel","labelHist","topLabels","sort","el","findBoxes","similarMoments","topCluster","patchPos","eligibleMoments","matchingMoments","minComponentWeight","rasterizeAngularSimilarity","currIdx","notYetProcessed","currentIdx","currentPatch","Rasterizer","createContour2D","firstVertex","insideContours","nextpeer","prevpeer","CONTOUR_DIR","CW_DIR","CCW_DIR","UNKNOWN_DIR","OUTSIDE_EDGE","INSIDE_EDGE","tracer","depthlabel","bc","lc","labelindex","colorMap","vertex","p","cc","sc","connectedCount","drawContour","firstContour","pq","iq","q","Skeletonizer","stdlib","foreign","images","inImagePtr","outImagePtr","aImagePtr","bImagePtr","imagePtr","memcpy","srcImagePtr","dstImagePtr","subImagePtr","erodedImagePtr","tempImagePtr","skelImagePtr","done","CodabarReader","_counters","START_END","MIN_ENCODED_CHARS","MAX_ACCEPTABLE","PADDING","startCounter","_isStartEnd","_verifyWhitespace","_validateResult","_sumCounters","endCounter","_calculatePatternLength","_thresholdResultPattern","categorization","space","narrow","counts","wide","bar","cat","_charToPattern","newkind","char","charCode","charCodeAt","thresholds","_computeAlternatingThreshold","barThreshold","spaceThreshold","bitmask","Code128Reader","CODE_SHIFT","CODE_C","CODE_B","CODE_A","START_CODE_A","START_CODE_B","START_CODE_C","STOP_CODE","MODULE_INDICES","_correct","calculateCorrection","multiplier","checksum","rawResult","shiftNext","removeLastCharacter","splice","expected","sumNormalized","sumExpected","Code39VINReader","patterns","IOQ","AZ09","replace","_checkChecksum","EAN2Reader","parseInt","EAN5Reader","CHECK_DIGIT_ENCODINGS","extensionChecksum","determineCheckDigit","EAN8Reader","I2of5Reader","barSpaceRatio","normalizeBarSpaceWidth","N","W","writable","MAX_CORRECTION_FACTOR","counterSum","codeSum","correctionRatio","correctionRatioInverse","narrowBarWidth","_decodePair","counterPair","codes","counterLength","_verifyCounterLength","UPCEReader","_determineParity","nrSystem","_convertToUPCA","upca","lastDigit","UPCReader","charAt","substring"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA,mDAA2C,cAAc;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,QAAQ;AACrB,aAAa,QAAQ;AACrB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,cAAc,OAAO;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClIA;;AAEA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa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CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/BA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;;AAEA;AACA;;AAEA;;;;;;;ACLA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,cAAc;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,iBAAiB;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA,6BAA6B,kBAAkB,EAAE;AACjD;AACA;AACA;AACA;AACA;AACA,8CAA8C,kBAAkB,EAAE;AAClE;AACA;AACA;;AAEA;;;;;;;ACnCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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CA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,EAAE;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC3BA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,EAAE;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;;AAEA;;;;;;;ACxBA;;AAEA;AACA;AACA;AACA;AACA,WAAW,YAAY;AACvB,aAAa,YAAY;AACzB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACjBA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;ACrCA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AClCA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA,YAAY,SAAS,GAAG,SAAS;AACjC;AACA;AACA;AACA,YAAY,SAAS,GAAG,SAAS;AACjC;AACA;AACA;AACA,UAAU,QAAQ,iBAAiB,GAAG,iBAAiB;AACvD;AACA;AACA;AACA,CAAC;;AAED;;;;;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;;;;;;;;;;ACrBA;;;AAGA,IAAInH,SAAS;AACTqL,sBAAkB,CAAC,CAAC,CAAD,EAAI,CAAJ,CAAD,EAAS,CAAC,CAAD,EAAI,CAAJ,CAAT,EAAiB,CAAC,CAAD,EAAI,CAAJ,CAAjB,EAAyB,CAAC,CAAD,EAAI,CAAC,CAAL,CAAzB,EAAkC,CAAC,CAAD,EAAI,CAAC,CAAL,CAAlC,EAA2C,CAAC,CAAC,CAAF,EAAK,CAAC,CAAN,CAA3C,EAAqD,CAAC,CAAC,CAAF,EAAK,CAAL,CAArD,EAA8D,CAAC,CAAC,CAAF,EAAK,CAAL,CAA9D,CADT;AAETzY,YA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;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChDA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB;AACA,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,EAAE;AACb;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,EAAE;AACf;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACvBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;AClCA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA,GAAG;AACH,CAAC;;AAED;;;;;;;ACVA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;;AAEA;;;;;;;;ACHA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnCA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;;AAEA;;;;;;;ACbA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,EAAE;AACf;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7DA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtBA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;;;;;;;;;;kQCpB0C;AACE;;;AAD5C;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA,IAAM5P,OAAO;AACTC,WAAO,mBAAAC,CAAQ,EAAR;AADE,CAAb;;AAIA,IAAIiR,YAAJ;AAAA,IACIC,aADJ;AAAA,IAEIC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,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACA;AACA;AACA;AACA;AACA,C;;;;;;ACdA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,C;;;;;;AChBA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,C;;;;;;ACdA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACNA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/BA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACNA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACNA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACNA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,MAAM;AACjB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;ACxJA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;;AAEA;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACZA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oCAAoC;;AAEpC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC3DA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5FA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;AClBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,WAAW,EAAE;AACb,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACbA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO,WAAW;AAC7B,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO,WAAW;AAC7B,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;ACpCA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxBA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzDA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;AC/EA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;;AAEA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACZA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AClCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;AClBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;ACjBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;;AAEA;;;;;;;ACzBA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH,CAAC;;AAED;;;;;;;;ACrBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,MAAM;AACjB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACbA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjCA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,CAAC;;AAED;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,QAAQ;AACrB;AACA;AACA,0BAA0B,gBAAgB,SAAS,GAAG;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA,iBAAiB;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,qBAAqB;AAChC,aAAa,OAAO;AACpB;AACA;AACA,iBAAiB;AACjB;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;;;;;;ACxDA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,qBAAqB;AAChC,aAAa,OAAO;AACpB;AACA;AACA,iBAAiB;AACjB;AACA;AACA,UAAU;AACV;AACA;AACA,4BAA4B;AAC5B,CAAC;;AAED;;;;;;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB,UAAU;AACV;AACA,aAAa,SAAS;AACtB,UAAU;AACV;AACA;AACA;AACA;;AAEA;;;;;;;AC/BA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;AC3BA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB;AACpB,0BAA0B;AAC1B;AACA;AACA;AACA,yDAAyD;AACzD,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,iDAAiD;AACjD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,kBAAkB,OAAO;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;;;;;;;ACrkBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;AC1FD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA,aAAa;AACb,WAAW;AACX;AACA,OAAO;AACP;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,WAAW;;AAEX;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf,WAAW;AACX;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA,eAAe;AACf;AACA,WAAW;AACX;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACxQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,YAAY;;AAEvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA,yDAAyD,qBAAqB;AAC9E,yDAAyD;AACzD;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;;AAEA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA,aAAa;AACb,WAAW;AACX,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACrMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW;;AAEX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,qBAAqB;AAC9C;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,sCAAsC;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,iCAAiC,gCAAgC;AACjE;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,WAAW;;AAEX;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;;AAEf;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;;AAE/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,eAAe;;AAEf;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA;AACA,eAAe;;AAEf;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA,WAAW;;AAEX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA,eAAe;AACf,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA,WAAW;AACX;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wDAAwD;AACxD,SAAS;AACT,OAAO;AACP;AACA;AACA,yBAAyB,8BAA8B;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,WAAW;AACX;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;;;;;;ACtmCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa,yCAAyC;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA,aAAa;AACb,WAAW;AACX;AACA,OAAO;AACP;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,gCAAgC;AAC3D;AACA;AACA,+BAA+B,wBAAwB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACjKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA,8BAA8B;AAC9B,oCAAoC,EAAE;AACtC,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,gEAAgE;AAC7E,aAAa;AACb;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AChKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,EAAE;;AAEhC;AACA;AACA,qCAAqC,EAAE;;AAEvC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA,iD;;;;;;ACAA,iD;;;;;;ACAA,iD","file":"quagga.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"get-pixels\"), require(\"ndarray\"), require(\"ndarray-linear-interpolate\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"get-pixels\", \"ndarray\", \"ndarray-linear-interpolate\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Quagga\"] = factory(require(\"get-pixels\"), require(\"ndarray\"), require(\"ndarray-linear-interpolate\"));\n\telse\n\t\troot[\"Quagga\"] = factory(root[\"get-pixels\"], root[\"ndarray\"], root[\"ndarray-linear-interpolate\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_211__, __WEBPACK_EXTERNAL_MODULE_212__, __WEBPACK_EXTERNAL_MODULE_213__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 214);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 4c48b12438da9b36927e","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\n\nvar logDisabled_ = true;\n\n// Utility methods.\nvar utils = {\n  disableLog: function(bool) {\n    if (typeof bool !== 'boolean') {\n      return new Error('Argument type: ' + typeof bool +\n          '. Please use a boolean.');\n    }\n    logDisabled_ = bool;\n    return (bool) ? 'adapter.js logging disabled' :\n        'adapter.js logging enabled';\n  },\n\n  log: function() {\n    if (typeof window === 'object') {\n      if (logDisabled_) {\n        return;\n      }\n      if (typeof console !== 'undefined' && typeof console.log === 'function') {\n        console.log.apply(console, arguments);\n      }\n    }\n  },\n\n  /**\n   * Extract browser version out of the provided user agent string.\n   *\n   * @param {!string} uastring userAgent string.\n   * @param {!string} expr Regular expression used as match criteria.\n   * @param {!number} pos position in the version string to be returned.\n   * @return {!number} browser version.\n   */\n  extractVersion: function(uastring, expr, pos) {\n    var match = uastring.match(expr);\n    return match && match.length >= pos && parseInt(match[pos], 10);\n  },\n\n  /**\n   * Browser detector.\n   *\n   * @return {object} result containing browser and version\n   *     properties.\n   */\n  detectBrowser: function() {\n    // Returned result object.\n    var result = {};\n    result.browser = null;\n    result.version = null;\n\n    // Fail early if it's not a browser\n    if (typeof window === 'undefined' || !window.navigator) {\n      result.browser = 'Not a browser.';\n      return result;\n    }\n\n    // Firefox.\n    if (navigator.mozGetUserMedia) {\n      result.browser = 'firefox';\n      result.version = this.extractVersion(navigator.userAgent,\n          /Firefox\\/([0-9]+)\\./, 1);\n\n    // all webkit-based browsers\n    } else if (navigator.webkitGetUserMedia) {\n      // Chrome, Chromium, Webview, Opera, all use the chrome shim for now\n      if (window.webkitRTCPeerConnection) {\n        result.browser = 'chrome';\n        result.version = this.extractVersion(navigator.userAgent,\n          /Chrom(e|ium)\\/([0-9]+)\\./, 2);\n\n      // Safari or unknown webkit-based\n      // for the time being Safari has support for MediaStreams but not webRTC\n      } else {\n        // Safari UA substrings of interest for reference:\n        // - webkit version:           AppleWebKit/602.1.25 (also used in Op,Cr)\n        // - safari UI version:        Version/9.0.3 (unique to Safari)\n        // - safari UI webkit version: Safari/601.4.4 (also used in Op,Cr)\n        //\n        // if the webkit version and safari UI webkit versions are equals,\n        // ... this is a stable version.\n        //\n        // only the internal webkit version is important today to know if\n        // media streams are supported\n        //\n        if (navigator.userAgent.match(/Version\\/(\\d+).(\\d+)/)) {\n          result.browser = 'safari';\n          result.version = this.extractVersion(navigator.userAgent,\n            /AppleWebKit\\/([0-9]+)\\./, 1);\n\n        // unknown webkit-based browser\n        } else {\n          result.browser = 'Unsupported webkit-based browser ' +\n              'with GUM support but no WebRTC support.';\n          return result;\n        }\n      }\n\n    // Edge.\n    } else if (navigator.mediaDevices &&\n        navigator.userAgent.match(/Edge\\/(\\d+).(\\d+)$/)) {\n      result.browser = 'edge';\n      result.version = this.extractVersion(navigator.userAgent,\n          /Edge\\/(\\d+).(\\d+)$/, 2);\n\n    // Default fallthrough: not supported.\n    } else {\n      result.browser = 'Not a supported browser.';\n      return result;\n    }\n\n    return result;\n  }\n};\n\n// Export.\nmodule.exports = {\n  log: utils.log,\n  disableLog: utils.disableLog,\n  browserDetails: utils.detectBrowser(),\n  extractVersion: utils.extractVersion\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/utils.js\n// module id = 0\n// module chunks = 0","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_root.js\n// module id = 1\n// module chunks = 0","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArray.js\n// module id = 2\n// module chunks = 0","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isObject.js\n// module id = 3\n// module chunks = 0","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getNative.js\n// module id = 4\n// module chunks = 0","import BarcodeReader from './barcode_reader';\nimport {merge} from 'lodash';\n\nfunction EANReader(opts, supplements) {\n    opts = merge(getDefaulConfig(), opts);\n    BarcodeReader.call(this, opts, supplements);\n}\n\nfunction getDefaulConfig() {\n    var config = {};\n\n    Object.keys(EANReader.CONFIG_KEYS).forEach(function(key) {\n        config[key] = EANReader.CONFIG_KEYS[key].default;\n    });\n    return config;\n}\n\nvar properties = {\n    CODE_L_START: {value: 0},\n    CODE_G_START: {value: 10},\n    START_PATTERN: {value: [1, 1, 1]},\n    STOP_PATTERN: {value: [1, 1, 1]},\n    MIDDLE_PATTERN: {value: [1, 1, 1, 1, 1]},\n    EXTENSION_START_PATTERN: {value: [1, 1, 2]},\n    CODE_PATTERN: {value: [\n        [3, 2, 1, 1],\n        [2, 2, 2, 1],\n        [2, 1, 2, 2],\n        [1, 4, 1, 1],\n        [1, 1, 3, 2],\n        [1, 2, 3, 1],\n        [1, 1, 1, 4],\n        [1, 3, 1, 2],\n        [1, 2, 1, 3],\n        [3, 1, 1, 2],\n        [1, 1, 2, 3],\n        [1, 2, 2, 2],\n        [2, 2, 1, 2],\n        [1, 1, 4, 1],\n        [2, 3, 1, 1],\n        [1, 3, 2, 1],\n        [4, 1, 1, 1],\n        [2, 1, 3, 1],\n        [3, 1, 2, 1],\n        [2, 1, 1, 3]\n    ]},\n    CODE_FREQUENCY: {value: [0, 11, 13, 14, 19, 25, 28, 21, 22, 26]},\n    SINGLE_CODE_ERROR: {value: 0.70},\n    AVG_CODE_ERROR: {value: 0.48},\n    FORMAT: {value: \"ean_13\", writeable: false}\n};\n\nEANReader.prototype = Object.create(BarcodeReader.prototype, properties);\nEANReader.prototype.constructor = EANReader;\n\nEANReader.prototype._decodeCode = function(start, coderange) {\n    var counter = [0, 0, 0, 0],\n        i,\n        self = this,\n        offset = start,\n        isWhite = !self._row[offset],\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start\n        },\n        code,\n        error;\n\n    if (!coderange) {\n        coderange = self.CODE_PATTERN.length;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                for (code = 0; code < coderange; code++) {\n                    error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n                    if (error < bestMatch.error) {\n                        bestMatch.code = code;\n                        bestMatch.error = error;\n                    }\n                }\n                bestMatch.end = i;\n                if (bestMatch.error > self.AVG_CODE_ERROR) {\n                    return null;\n                }\n                return bestMatch;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._findPattern = function(pattern, offset, isWhite, tryHarder, epsilon) {\n    var counter = [],\n        self = this,\n        i,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        },\n        error,\n        j,\n        sum;\n\n    if (!offset) {\n        offset = self._nextSet(self._row);\n    }\n\n    if (isWhite === undefined) {\n        isWhite = false;\n    }\n\n    if (tryHarder === undefined) {\n        tryHarder = true;\n    }\n\n    if ( epsilon === undefined) {\n        epsilon = self.AVG_CODE_ERROR;\n    }\n\n    for ( i = 0; i < pattern.length; i++) {\n        counter[i] = 0;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                error = self._matchPattern(counter, pattern);\n\n                if (error < epsilon) {\n                    bestMatch.error = error;\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    return bestMatch;\n                }\n                if (tryHarder) {\n                    for ( j = 0; j < counter.length - 2; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[counter.length - 2] = 0;\n                    counter[counter.length - 1] = 0;\n                    counterPos--;\n                } else {\n                    return null;\n                }\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._findStart = function() {\n    var self = this,\n        leadingWhitespaceStart,\n        offset = self._nextSet(self._row),\n        startInfo;\n\n    while (!startInfo) {\n        startInfo = self._findPattern(self.START_PATTERN, offset);\n        if (!startInfo) {\n            return null;\n        }\n        leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);\n        if (leadingWhitespaceStart >= 0) {\n            if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                return startInfo;\n            }\n        }\n        offset = startInfo.end;\n        startInfo = null;\n    }\n};\n\nEANReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._findEnd = function(offset, isWhite) {\n    var self = this,\n        endInfo = self._findPattern(self.STOP_PATTERN, offset, isWhite, false);\n\n    return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;\n};\n\nEANReader.prototype._calculateFirstDigit = function(codeFrequency) {\n    var i,\n        self = this;\n\n    for ( i = 0; i < self.CODE_FREQUENCY.length; i++) {\n        if (codeFrequency === self.CODE_FREQUENCY[i]) {\n            return i;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._decodePayload = function(code, result, decodedCodes) {\n    var i,\n        self = this,\n        codeFrequency = 0x0,\n        firstDigit;\n\n    for ( i = 0; i < 6; i++) {\n        code = self._decodeCode(code.end);\n        if (!code) {\n            return null;\n        }\n        if (code.code >= self.CODE_G_START) {\n            code.code = code.code - self.CODE_G_START;\n            codeFrequency |= 1 << (5 - i);\n        } else {\n            codeFrequency |= 0 << (5 - i);\n        }\n        result.push(code.code);\n        decodedCodes.push(code);\n    }\n\n    firstDigit = self._calculateFirstDigit(codeFrequency);\n    if (firstDigit === null) {\n        return null;\n    }\n    result.unshift(firstDigit);\n\n    code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);\n    if (code === null) {\n        return null;\n    }\n    decodedCodes.push(code);\n\n    for ( i = 0; i < 6; i++) {\n        code = self._decodeCode(code.end, self.CODE_G_START);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code);\n    }\n\n    return code;\n};\n\nEANReader.prototype._decode = function() {\n    var startInfo,\n        self = this,\n        code,\n        result = [],\n        decodedCodes = [],\n        resultInfo = {};\n\n    startInfo = self._findStart();\n    if (!startInfo) {\n        return null;\n    }\n    code = {\n        code: startInfo.code,\n        start: startInfo.start,\n        end: startInfo.end\n    };\n    decodedCodes.push(code);\n    code = self._decodePayload(code, result, decodedCodes);\n    if (!code) {\n        return null;\n    }\n    code = self._findEnd(code.end, false);\n    if (!code){\n        return null;\n    }\n\n    decodedCodes.push(code);\n\n    // Checksum\n    if (!self._checksum(result)) {\n        return null;\n    }\n\n    if (this.supplements.length > 0) {\n        let ext = this._decodeExtensions(code.end);\n        if (!ext) {\n            return null;\n        }\n        let lastCode = ext.decodedCodes[ext.decodedCodes.length-1],\n            endInfo = {\n                start: lastCode.start + (((lastCode.end - lastCode.start) / 2) | 0),\n                end: lastCode.end\n            };\n        if(!self._verifyTrailingWhitespace(endInfo)) {\n            return null;\n        }\n        resultInfo = {\n            supplement: ext,\n            code: result.join(\"\") + ext.code\n        }\n    }\n\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: code.end,\n        codeset: \"\",\n        startInfo: startInfo,\n        decodedCodes: decodedCodes,\n        ...resultInfo\n    };\n};\n\nEANReader.prototype._decodeExtensions = function(offset) {\n    var i,\n        start = this._nextSet(this._row, offset),\n        startInfo = this._findPattern(this.EXTENSION_START_PATTERN, start, false, false),\n        result;\n\n    if (startInfo === null) {\n        return null;\n    }\n\n    for (i = 0; i < this.supplements.length; i++) {\n        result = this.supplements[i].decode(this._row, startInfo.end);\n        if (result !== null) {\n            return {\n                code: result.code,\n                start,\n                startInfo,\n                end: result.end,\n                codeset: \"\",\n                decodedCodes: result.decodedCodes\n            }\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._checksum = function(result) {\n    var sum = 0, i;\n\n    for ( i = result.length - 2; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    sum *= 3;\n    for ( i = result.length - 1; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    return sum % 10 === 0;\n};\n\nEANReader.CONFIG_KEYS = {\n    supplements: {\n        'type': 'arrayOf(string)',\n        'default': [],\n        'description': 'Allowed extensions to be decoded (2 and/or 5)'\n    }\n};\n\nexport default (EANReader);\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_reader.js","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseGetTag.js\n// module id = 6\n// module chunks = 0","var isArray = require('./isArray'),\n    isKey = require('./_isKey'),\n    stringToPath = require('./_stringToPath'),\n    toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n  if (isArray(value)) {\n    return value;\n  }\n  return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_castPath.js\n// module id = 7\n// module chunks = 0","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_copyObject.js\n// module id = 8\n// module chunks = 0","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isObjectLike.js\n// module id = 9\n// module chunks = 0","function BarcodeReader(config, supplements) {\n    this._row = [];\n    this.config = config || {};\n    this.supplements = supplements;\n    return this;\n}\n\nBarcodeReader.prototype._nextUnset = function(line, start) {\n    var i;\n\n    if (start === undefined) {\n        start = 0;\n    }\n    for (i = start; i < line.length; i++) {\n        if (!line[i]) {\n            return i;\n        }\n    }\n    return line.length;\n};\n\nBarcodeReader.prototype._matchPattern = function(counter, code, maxSingleError) {\n    var i,\n        error = 0,\n        singleError = 0,\n        sum = 0,\n        modulo = 0,\n        barWidth,\n        count,\n        scaled;\n\n    maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;\n\n    for (i = 0; i < counter.length; i++) {\n        sum += counter[i];\n        modulo += code[i];\n    }\n    if (sum < modulo) {\n        return Number.MAX_VALUE;\n    }\n    barWidth = sum / modulo;\n    maxSingleError *= barWidth;\n\n    for (i = 0; i < counter.length; i++) {\n        count = counter[i];\n        scaled = code[i] * barWidth;\n        singleError = Math.abs(count - scaled) / scaled;\n        if (singleError > maxSingleError) {\n            return Number.MAX_VALUE;\n        }\n        error += singleError;\n    }\n    return error / modulo;\n};\n\nBarcodeReader.prototype._nextSet = function(line, offset) {\n    var i;\n\n    offset = offset || 0;\n    for (i = offset; i < line.length; i++) {\n        if (line[i]) {\n            return i;\n        }\n    }\n    return line.length;\n};\n\nBarcodeReader.prototype._correctBars = function(counter, correction, indices) {\n    var length = indices.length,\n        tmp = 0;\n    while(length--) {\n        tmp = counter[indices[length]] * (1 - ((1 - correction) / 2));\n        if (tmp > 1) {\n            counter[indices[length]] = tmp;\n        }\n    }\n}\n\nBarcodeReader.prototype._matchTrace = function(cmpCounter, epsilon) {\n    var counter = [],\n        i,\n        self = this,\n        offset = self._nextSet(self._row),\n        isWhite = !self._row[offset],\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0\n        },\n        error;\n\n    if (cmpCounter) {\n        for ( i = 0; i < cmpCounter.length; i++) {\n            counter.push(0);\n        }\n        for ( i = offset; i < self._row.length; i++) {\n            if (self._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    error = self._matchPattern(counter, cmpCounter);\n\n                    if (error < epsilon) {\n                        bestMatch.start = i - offset;\n                        bestMatch.end = i;\n                        bestMatch.counter = counter;\n                        return bestMatch;\n                    } else {\n                        return null;\n                    }\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = !isWhite;\n            }\n        }\n    } else {\n        counter.push(0);\n        for ( i = offset; i < self._row.length; i++) {\n            if (self._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                counterPos++;\n                counter.push(0);\n                counter[counterPos] = 1;\n                isWhite = !isWhite;\n            }\n        }\n    }\n\n    // if cmpCounter was not given\n    bestMatch.start = offset;\n    bestMatch.end = self._row.length - 1;\n    bestMatch.counter = counter;\n    return bestMatch;\n};\n\nBarcodeReader.prototype.decodePattern = function(pattern) {\n    var self = this,\n        result;\n\n    self._row = pattern;\n    result = self._decode();\n    if (result === null) {\n        self._row.reverse();\n        result = self._decode();\n        if (result) {\n            result.direction = BarcodeReader.DIRECTION.REVERSE;\n            result.start = self._row.length - result.start;\n            result.end = self._row.length - result.end;\n        }\n    } else {\n        result.direction = BarcodeReader.DIRECTION.FORWARD;\n    }\n    if (result) {\n        result.format = self.FORMAT;\n    }\n    return result;\n};\n\nBarcodeReader.prototype._matchRange = function(start, end, value) {\n    var i;\n\n    start = start < 0 ? 0 : start;\n    for (i = start; i < end; i++) {\n        if (this._row[i] !== value) {\n            return false;\n        }\n    }\n    return true;\n};\n\nBarcodeReader.prototype._fillCounters = function(offset, end, isWhite) {\n    var self = this,\n        counterPos = 0,\n        i,\n        counters = [];\n\n    isWhite = (typeof isWhite !== 'undefined') ? isWhite : true;\n    offset = (typeof offset !== 'undefined') ? offset : self._nextUnset(self._row);\n    end = end || self._row.length;\n\n    counters[counterPos] = 0;\n    for (i = offset; i < end; i++) {\n        if (self._row[i] ^ isWhite) {\n            counters[counterPos]++;\n        } else {\n            counterPos++;\n            counters[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return counters;\n};\n\nObject.defineProperty(BarcodeReader.prototype, \"FORMAT\", {\n    value: 'unknown',\n    writeable: false\n});\n\nBarcodeReader.DIRECTION = {\n    FORWARD: 1,\n    REVERSE: -1\n};\n\nBarcodeReader.Exception = {\n    StartNotFoundException: \"Start-Info was not found!\",\n    CodeNotFoundException: \"Code could not be found!\",\n    PatternNotFoundException: \"Pattern could not be found!\"\n};\n\nBarcodeReader.CONFIG_KEYS = {};\n\nexport default BarcodeReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/barcode_reader.js","module.exports = clone\n\n/**\n * Creates a new vec2 initialized with values from an existing vector\n *\n * @param {vec2} a vector to clone\n * @returns {vec2} a new 2D vector\n */\nfunction clone(a) {\n    var out = new Float32Array(2)\n    out[0] = a[0]\n    out[1] = a[1]\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/clone.js\n// module id = 11\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Symbol.js\n// module id = 12\n// module chunks = 0","export default {\n    init: function(arr, val) {\n        var l = arr.length;\n        while (l--) {\n            arr[l] = val;\n        }\n    },\n\n    /**\n     * Shuffles the content of an array\n     * @return {Array} the array itself shuffled\n     */\n    shuffle: function(arr) {\n        var i = arr.length - 1, j, x;\n        for (i; i >= 0; i--) {\n            j = Math.floor(Math.random() * i);\n            x = arr[i];\n            arr[i] = arr[j];\n            arr[j] = x;\n        }\n        return arr;\n    },\n\n    toPointList: function(arr) {\n        var i, j, row = [], rows = [];\n        for ( i = 0; i < arr.length; i++) {\n            row = [];\n            for ( j = 0; j < arr[i].length; j++) {\n                row[j] = arr[i][j];\n            }\n            rows[i] = \"[\" + row.join(\",\") + \"]\";\n        }\n        return \"[\" + rows.join(\",\\r\\n\") + \"]\";\n    },\n\n    /**\n     * returns the elements which's score is bigger than the threshold\n     * @return {Array} the reduced array\n     */\n    threshold: function(arr, threshold, scoreFunc) {\n        var i, queue = [];\n        for ( i = 0; i < arr.length; i++) {\n            if (scoreFunc.apply(arr, [arr[i]]) >= threshold) {\n                queue.push(arr[i]);\n            }\n        }\n        return queue;\n    },\n\n    maxIndex: function(arr) {\n        var i, max = 0;\n        for ( i = 0; i < arr.length; i++) {\n            if (arr[i] > arr[max]) {\n                max = i;\n            }\n        }\n        return max;\n    },\n\n    max: function(arr) {\n        var i, max = 0;\n        for ( i = 0; i < arr.length; i++) {\n            if (arr[i] > max) {\n                max = arr[i];\n            }\n        }\n        return max;\n    },\n\n    sum: function(arr) {\n        var length = arr.length,\n            sum = 0;\n\n        while (length--) {\n            sum += arr[length];\n        }\n        return sum;\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/array_helper.js","export default {\n    drawRect: function(pos, size, ctx, style){\n        ctx.strokeStyle = style.color;\n        ctx.fillStyle = style.color;\n        ctx.lineWidth = 1;\n        ctx.beginPath();\n        ctx.strokeRect(pos.x, pos.y, size.x, size.y);\n    },\n    drawPath: function(path, def, ctx, style) {\n        ctx.strokeStyle = style.color;\n        ctx.fillStyle = style.color;\n        ctx.lineWidth = style.lineWidth;\n        ctx.beginPath();\n        ctx.moveTo(path[0][def.x], path[0][def.y]);\n        for (var j = 1; j < path.length; j++) {\n            ctx.lineTo(path[j][def.x], path[j][def.y]);\n        }\n        ctx.closePath();\n        ctx.stroke();\n    },\n    drawImage: function(imageData, size, ctx) {\n        var canvasData = ctx.getImageData(0, 0, size.x, size.y),\n            data = canvasData.data,\n            imageDataPos = imageData.length,\n            canvasDataPos = data.length,\n            value;\n\n        if (canvasDataPos / imageDataPos !== 4) {\n            return false;\n        }\n        while (imageDataPos--){\n            value = imageData[imageDataPos];\n            data[--canvasDataPos] = 255;\n            data[--canvasDataPos] = value;\n            data[--canvasDataPos] = value;\n            data[--canvasDataPos] = value;\n        }\n        ctx.putImageData(canvasData, 0, 0);\n        return true;\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/image_debug.js","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_ListCache.js\n// module id = 15\n// module chunks = 0","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_assocIndexOf.js\n// module id = 16\n// module chunks = 0","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getMapData.js\n// module id = 17\n// module chunks = 0","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isIndex.js\n// module id = 18\n// module chunks = 0","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nativeCreate.js\n// module id = 19\n// module chunks = 0","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_toKey.js\n// module id = 20\n// module chunks = 0","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/eq.js\n// module id = 21\n// module chunks = 0","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArguments.js\n// module id = 22\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArrayLike.js\n// module id = 23\n// module chunks = 0","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/keysIn.js\n// module id = 24\n// module chunks = 0","import Cluster2 from './cluster';\nimport ArrayHelper from './array_helper';\nconst vec2 = {\n    clone: require('gl-vec2/clone'),\n};\nconst vec3 = {\n    clone: require('gl-vec3/clone'),\n};\n\n/**\n * @param x x-coordinate\n * @param y y-coordinate\n * @return ImageReference {x,y} Coordinate\n */\nexport function imageRef(x, y) {\n    var that = {\n        x: x,\n        y: y,\n        toVec2: function() {\n            return vec2.clone([this.x, this.y]);\n        },\n        toVec3: function() {\n            return vec3.clone([this.x, this.y, 1]);\n        },\n        round: function() {\n            this.x = this.x > 0.0 ? Math.floor(this.x + 0.5) : Math.floor(this.x - 0.5);\n            this.y = this.y > 0.0 ? Math.floor(this.y + 0.5) : Math.floor(this.y - 0.5);\n            return this;\n        }\n    };\n    return that;\n};\n\n/**\n * Computes an integral image of a given grayscale image.\n * @param imageDataContainer {ImageDataContainer} the image to be integrated\n */\nexport function computeIntegralImage2(imageWrapper, integralWrapper) {\n    var imageData = imageWrapper.data;\n    var width = imageWrapper.size.x;\n    var height = imageWrapper.size.y;\n    var integralImageData = integralWrapper.data;\n    var sum = 0, posA = 0, posB = 0, posC = 0, posD = 0, x, y;\n\n    // sum up first column\n    posB = width;\n    sum = 0;\n    for ( y = 1; y < height; y++) {\n        sum += imageData[posA];\n        integralImageData[posB] += sum;\n        posA += width;\n        posB += width;\n    }\n\n    posA = 0;\n    posB = 1;\n    sum = 0;\n    for ( x = 1; x < width; x++) {\n        sum += imageData[posA];\n        integralImageData[posB] += sum;\n        posA++;\n        posB++;\n    }\n\n    for ( y = 1; y < height; y++) {\n        posA = y * width + 1;\n        posB = (y - 1) * width + 1;\n        posC = y * width;\n        posD = (y - 1) * width;\n        for ( x = 1; x < width; x++) {\n            integralImageData[posA] +=\n                imageData[posA] + integralImageData[posB] + integralImageData[posC] - integralImageData[posD];\n            posA++;\n            posB++;\n            posC++;\n            posD++;\n        }\n    }\n};\n\nexport function computeIntegralImage(imageWrapper, integralWrapper) {\n    var imageData = imageWrapper.data;\n    var width = imageWrapper.size.x;\n    var height = imageWrapper.size.y;\n    var integralImageData = integralWrapper.data;\n    var sum = 0;\n\n    // sum up first row\n    for (var i = 0; i < width; i++) {\n        sum += imageData[i];\n        integralImageData[i] = sum;\n    }\n\n    for (var v = 1; v < height; v++) {\n        sum = 0;\n        for (var u = 0; u < width; u++) {\n            sum += imageData[v * width + u];\n            integralImageData[((v) * width) + u] = sum + integralImageData[(v - 1) * width + u];\n        }\n    }\n};\n\nexport function thresholdImage(imageWrapper, threshold, targetWrapper) {\n    if (!targetWrapper) {\n        targetWrapper = imageWrapper;\n    }\n    var imageData = imageWrapper.data, length = imageData.length, targetData = targetWrapper.data;\n\n    while (length--) {\n        targetData[length] = imageData[length] < threshold ? 1 : 0;\n    }\n};\n\nexport function computeHistogram(imageWrapper, bitsPerPixel) {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n    var imageData = imageWrapper.data,\n        length = imageData.length,\n        bitShift = 8 - bitsPerPixel,\n        bucketCnt = 1 << bitsPerPixel,\n        hist = new Int32Array(bucketCnt);\n\n    while (length--) {\n        hist[imageData[length] >> bitShift]++;\n    }\n    return hist;\n};\n\nexport function sharpenLine(line) {\n    var i,\n        length = line.length,\n        left = line[0],\n        center = line[1],\n        right;\n\n    for (i = 1; i < length - 1; i++) {\n        right = line[i + 1];\n        //  -1 4 -1 kernel\n        line[i - 1] = (((center * 2) - left - right)) & 255;\n        left = center;\n        center = right;\n    }\n    return line;\n};\n\nexport function determineOtsuThreshold(imageWrapper, bitsPerPixel) {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n    var hist,\n        threshold,\n        bitShift = 8 - bitsPerPixel;\n\n    function px(init, end) {\n        var sum = 0, i;\n        for ( i = init; i <= end; i++) {\n            sum += hist[i];\n        }\n        return sum;\n    }\n\n    function mx(init, end) {\n        var i, sum = 0;\n\n        for ( i = init; i <= end; i++) {\n            sum += i * hist[i];\n        }\n\n        return sum;\n    }\n\n    function determineThreshold() {\n        var vet = [0], p1, p2, p12, k, m1, m2, m12,\n            max = (1 << bitsPerPixel) - 1;\n\n        hist = computeHistogram(imageWrapper, bitsPerPixel);\n        for ( k = 1; k < max; k++) {\n            p1 = px(0, k);\n            p2 = px(k + 1, max);\n            p12 = p1 * p2;\n            if (p12 === 0) {\n                p12 = 1;\n            }\n            m1 = mx(0, k) * p2;\n            m2 = mx(k + 1, max) * p1;\n            m12 = m1 - m2;\n            vet[k] = m12 * m12 / p12;\n        }\n        return ArrayHelper.maxIndex(vet);\n    }\n\n    threshold = determineThreshold();\n    return threshold << bitShift;\n};\n\nexport function otsuThreshold(imageWrapper, targetWrapper) {\n    var threshold = determineOtsuThreshold(imageWrapper);\n\n    thresholdImage(imageWrapper, threshold, targetWrapper);\n    return threshold;\n};\n\n// local thresholding\nexport function computeBinaryImage(imageWrapper, integralWrapper, targetWrapper) {\n    computeIntegralImage(imageWrapper, integralWrapper);\n\n    if (!targetWrapper) {\n        targetWrapper = imageWrapper;\n    }\n    var imageData = imageWrapper.data;\n    var targetData = targetWrapper.data;\n    var width = imageWrapper.size.x;\n    var height = imageWrapper.size.y;\n    var integralImageData = integralWrapper.data;\n    var sum = 0, v, u, kernel = 3, A, B, C, D, avg, size = (kernel * 2 + 1) * (kernel * 2 + 1);\n\n    // clear out top & bottom-border\n    for ( v = 0; v <= kernel; v++) {\n        for ( u = 0; u < width; u++) {\n            targetData[((v) * width) + u] = 0;\n            targetData[(((height - 1) - v) * width) + u] = 0;\n        }\n    }\n\n    // clear out left & right border\n    for ( v = kernel; v < height - kernel; v++) {\n        for ( u = 0; u <= kernel; u++) {\n            targetData[((v) * width) + u] = 0;\n            targetData[((v) * width) + (width - 1 - u)] = 0;\n        }\n    }\n\n    for ( v = kernel + 1; v < height - kernel - 1; v++) {\n        for ( u = kernel + 1; u < width - kernel; u++) {\n            A = integralImageData[(v - kernel - 1) * width + (u - kernel - 1)];\n            B = integralImageData[(v - kernel - 1) * width + (u + kernel)];\n            C = integralImageData[(v + kernel) * width + (u - kernel - 1)];\n            D = integralImageData[(v + kernel) * width + (u + kernel)];\n            sum = D - C - B + A;\n            avg = sum / (size);\n            targetData[v * width + u] = imageData[v * width + u] > (avg + 5) ? 0 : 1;\n        }\n    }\n};\n\nexport function cluster(points, threshold, property) {\n    var i, k, cluster, point, clusters = [];\n\n    if (!property) {\n        property = \"rad\";\n    }\n\n    function addToCluster(newPoint) {\n        var found = false;\n        for ( k = 0; k < clusters.length; k++) {\n            cluster = clusters[k];\n            if (cluster.fits(newPoint)) {\n                cluster.add(newPoint);\n                found = true;\n            }\n        }\n        return found;\n    }\n\n    // iterate over each cloud\n    for ( i = 0; i < points.length; i++) {\n        point = Cluster2.createPoint(points[i], i, property);\n        if (!addToCluster(point)) {\n            clusters.push(Cluster2.create(point, threshold));\n        }\n    }\n    return clusters;\n};\n\nexport const Tracer = {\n    trace: function(points, vec) {\n        var iteration, maxIterations = 10, top = [], result = [], centerPos = 0, currentPos = 0;\n\n        function trace(idx, forward) {\n            var from, to, toIdx, predictedPos, thresholdX = 1, thresholdY = Math.abs(vec[1] / 10), found = false;\n\n            function match(pos, predicted) {\n                if (pos.x > (predicted.x - thresholdX)\n                        && pos.x < (predicted.x + thresholdX)\n                        && pos.y > (predicted.y - thresholdY)\n                        && pos.y < (predicted.y + thresholdY)) {\n                    return true;\n                } else {\n                    return false;\n                }\n            }\n\n            // check if the next index is within the vec specifications\n            // if not, check as long as the threshold is met\n\n            from = points[idx];\n            if (forward) {\n                predictedPos = {\n                    x: from.x + vec[0],\n                    y: from.y + vec[1]\n                };\n            } else {\n                predictedPos = {\n                    x: from.x - vec[0],\n                    y: from.y - vec[1]\n                };\n            }\n\n            toIdx = forward ? idx + 1 : idx - 1;\n            to = points[toIdx];\n            while (to && ( found = match(to, predictedPos)) !== true && (Math.abs(to.y - from.y) < vec[1])) {\n                toIdx = forward ? toIdx + 1 : toIdx - 1;\n                to = points[toIdx];\n            }\n\n            return found ? toIdx : null;\n        }\n\n        for ( iteration = 0; iteration < maxIterations; iteration++) {\n            // randomly select point to start with\n            centerPos = Math.floor(Math.random() * points.length);\n\n            // trace forward\n            top = [];\n            currentPos = centerPos;\n            top.push(points[currentPos]);\n            while (( currentPos = trace(currentPos, true)) !== null) {\n                top.push(points[currentPos]);\n            }\n            if (centerPos > 0) {\n                currentPos = centerPos;\n                while (( currentPos = trace(currentPos, false)) !== null) {\n                    top.push(points[currentPos]);\n                }\n            }\n\n            if (top.length > result.length) {\n                result = top;\n            }\n        }\n        return result;\n    }\n};\n\nexport const DILATE = 1;\nexport const ERODE = 2;\n\nexport function dilate(inImageWrapper, outImageWrapper) {\n    var v,\n        u,\n        inImageData = inImageWrapper.data,\n        outImageData = outImageWrapper.data,\n        height = inImageWrapper.size.y,\n        width = inImageWrapper.size.x,\n        sum,\n        yStart1,\n        yStart2,\n        xStart1,\n        xStart2;\n\n    for ( v = 1; v < height - 1; v++) {\n        for ( u = 1; u < width - 1; u++) {\n            yStart1 = v - 1;\n            yStart2 = v + 1;\n            xStart1 = u - 1;\n            xStart2 = u + 1;\n            sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] +\n            inImageData[v * width + u] +\n            inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];\n            outImageData[v * width + u] = sum > 0 ? 1 : 0;\n        }\n    }\n};\n\nexport function erode(inImageWrapper, outImageWrapper) {\n    var v,\n        u,\n        inImageData = inImageWrapper.data,\n        outImageData = outImageWrapper.data,\n        height = inImageWrapper.size.y,\n        width = inImageWrapper.size.x,\n        sum,\n        yStart1,\n        yStart2,\n        xStart1,\n        xStart2;\n\n    for ( v = 1; v < height - 1; v++) {\n        for ( u = 1; u < width - 1; u++) {\n            yStart1 = v - 1;\n            yStart2 = v + 1;\n            xStart1 = u - 1;\n            xStart2 = u + 1;\n            sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] +\n            inImageData[v * width + u] +\n            inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];\n            outImageData[v * width + u] = sum === 5 ? 1 : 0;\n        }\n    }\n};\n\nexport function subtract(aImageWrapper, bImageWrapper, resultImageWrapper) {\n    if (!resultImageWrapper) {\n        resultImageWrapper = aImageWrapper;\n    }\n    var length = aImageWrapper.data.length,\n        aImageData = aImageWrapper.data,\n        bImageData = bImageWrapper.data,\n        cImageData = resultImageWrapper.data;\n\n    while (length--) {\n        cImageData[length] = aImageData[length] - bImageData[length];\n    }\n};\n\nexport function bitwiseOr(aImageWrapper, bImageWrapper, resultImageWrapper) {\n    if (!resultImageWrapper) {\n        resultImageWrapper = aImageWrapper;\n    }\n    var length = aImageWrapper.data.length,\n        aImageData = aImageWrapper.data,\n        bImageData = bImageWrapper.data,\n        cImageData = resultImageWrapper.data;\n\n    while (length--) {\n        cImageData[length] = aImageData[length] || bImageData[length];\n    }\n};\n\nexport function countNonZero(imageWrapper) {\n    var length = imageWrapper.data.length, data = imageWrapper.data, sum = 0;\n\n    while (length--) {\n        sum += data[length];\n    }\n    return sum;\n};\n\nexport function topGeneric(list, top, scoreFunc) {\n    var i, minIdx = 0, min = 0, queue = [], score, hit, pos;\n\n    for ( i = 0; i < top; i++) {\n        queue[i] = {\n            score: 0,\n            item: null\n        };\n    }\n\n    for ( i = 0; i < list.length; i++) {\n        score = scoreFunc.apply(this, [list[i]]);\n        if (score > min) {\n            hit = queue[minIdx];\n            hit.score = score;\n            hit.item = list[i];\n            min = Number.MAX_VALUE;\n            for ( pos = 0; pos < top; pos++) {\n                if (queue[pos].score < min) {\n                    min = queue[pos].score;\n                    minIdx = pos;\n                }\n            }\n        }\n    }\n\n    return queue;\n};\n\nexport function grayArrayFromImage(htmlImage, offsetX, ctx, array) {\n    ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height);\n    var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data;\n    computeGray(ctxData, array);\n};\n\nexport function grayArrayFromContext(ctx, size, offset, array) {\n    var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data;\n    computeGray(ctxData, array);\n};\n\nexport function grayAndHalfSampleFromCanvasData(canvasData, size, outArray) {\n    var topRowIdx = 0;\n    var bottomRowIdx = size.x;\n    var endIdx = Math.floor(canvasData.length / 4);\n    var outWidth = size.x / 2;\n    var outImgIdx = 0;\n    var inWidth = size.x;\n    var i;\n\n    while (bottomRowIdx < endIdx) {\n        for ( i = 0; i < outWidth; i++) {\n            outArray[outImgIdx] = Math.floor((\n                (0.299 * canvasData[topRowIdx * 4 + 0] +\n                 0.587 * canvasData[topRowIdx * 4 + 1] +\n                 0.114 * canvasData[topRowIdx * 4 + 2]) +\n                (0.299 * canvasData[(topRowIdx + 1) * 4 + 0] +\n                 0.587 * canvasData[(topRowIdx + 1) * 4 + 1] +\n                 0.114 * canvasData[(topRowIdx + 1) * 4 + 2]) +\n                (0.299 * canvasData[(bottomRowIdx) * 4 + 0] +\n                 0.587 * canvasData[(bottomRowIdx) * 4 + 1] +\n                 0.114 * canvasData[(bottomRowIdx) * 4 + 2]) +\n                (0.299 * canvasData[(bottomRowIdx + 1) * 4 + 0] +\n                 0.587 * canvasData[(bottomRowIdx + 1) * 4 + 1] +\n                 0.114 * canvasData[(bottomRowIdx + 1) * 4 + 2])) / 4);\n            outImgIdx++;\n            topRowIdx = topRowIdx + 2;\n            bottomRowIdx = bottomRowIdx + 2;\n        }\n        topRowIdx = topRowIdx + inWidth;\n        bottomRowIdx = bottomRowIdx + inWidth;\n    }\n};\n\nexport function computeGray(imageData, outArray, config) {\n    var l = (imageData.length / 4) | 0,\n        i,\n        singleChannel = config && config.singleChannel === true;\n\n    if (singleChannel) {\n        for (i = 0; i < l; i++) {\n            outArray[i] = imageData[i * 4 + 0];\n        }\n    } else {\n        for (i = 0; i < l; i++) {\n            outArray[i] = Math.floor(\n                0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2]);\n        }\n    }\n};\n\nexport function loadImageArray(src, callback, canvas) {\n    if (!canvas) {\n        canvas = document.createElement('canvas');\n    }\n    var img = new Image();\n    img.callback = callback;\n    img.onload = function() {\n        canvas.width = this.width;\n        canvas.height = this.height;\n        var ctx = canvas.getContext('2d');\n        ctx.drawImage(this, 0, 0);\n        var array = new Uint8Array(this.width * this.height);\n        ctx.drawImage(this, 0, 0);\n        var data = ctx.getImageData(0, 0, this.width, this.height).data;\n        computeGray(data, array);\n        this.callback(array, {\n            x: this.width,\n            y: this.height\n        }, this);\n    };\n    img.src = src;\n};\n\n/**\n * @param inImg {ImageWrapper} input image to be sampled\n * @param outImg {ImageWrapper} to be stored in\n */\nexport function halfSample(inImgWrapper, outImgWrapper) {\n    var inImg = inImgWrapper.data;\n    var inWidth = inImgWrapper.size.x;\n    var outImg = outImgWrapper.data;\n    var topRowIdx = 0;\n    var bottomRowIdx = inWidth;\n    var endIdx = inImg.length;\n    var outWidth = inWidth / 2;\n    var outImgIdx = 0;\n    while (bottomRowIdx < endIdx) {\n        for (var i = 0; i < outWidth; i++) {\n            outImg[outImgIdx] = Math.floor(\n                (inImg[topRowIdx] + inImg[topRowIdx + 1] + inImg[bottomRowIdx] + inImg[bottomRowIdx + 1]) / 4);\n            outImgIdx++;\n            topRowIdx = topRowIdx + 2;\n            bottomRowIdx = bottomRowIdx + 2;\n        }\n        topRowIdx = topRowIdx + inWidth;\n        bottomRowIdx = bottomRowIdx + inWidth;\n    }\n};\n\nexport function hsv2rgb(hsv, rgb) {\n    var h = hsv[0],\n        s = hsv[1],\n        v = hsv[2],\n        c = v * s,\n        x = c * (1 - Math.abs((h / 60) % 2 - 1)),\n        m = v - c,\n        r = 0,\n        g = 0,\n        b = 0;\n\n    rgb = rgb || [0, 0, 0];\n\n    if (h < 60) {\n        r = c;\n        g = x;\n    } else if (h < 120) {\n        r = x;\n        g = c;\n    } else if (h < 180) {\n        g = c;\n        b = x;\n    } else if (h < 240) {\n        g = x;\n        b = c;\n    } else if (h < 300) {\n        r = x;\n        b = c;\n    } else if (h < 360) {\n        r = c;\n        b = x;\n    }\n    rgb[0] = ((r + m) * 255) | 0;\n    rgb[1] = ((g + m) * 255) | 0;\n    rgb[2] = ((b + m) * 255) | 0;\n    return rgb;\n};\n\nexport function _computeDivisors(n) {\n    var largeDivisors = [],\n        divisors = [],\n        i;\n\n    for (i = 1; i < Math.sqrt(n) + 1; i++) {\n        if (n % i === 0) {\n            divisors.push(i);\n            if (i !== n / i) {\n                largeDivisors.unshift(Math.floor(n / i));\n            }\n        }\n    }\n    return divisors.concat(largeDivisors);\n};\n\nfunction _computeIntersection(arr1, arr2) {\n    var i = 0,\n        j = 0,\n        result = [];\n\n    while (i < arr1.length && j < arr2.length) {\n        if (arr1[i] === arr2[j]) {\n            result.push(arr1[i]);\n            i++;\n            j++;\n        } else if (arr1[i] > arr2[j]) {\n            j++;\n        } else {\n            i++;\n        }\n    }\n    return result;\n};\n\nexport function calculatePatchSize(patchSize, imgSize) {\n    var divisorsX = _computeDivisors(imgSize.x),\n        divisorsY = _computeDivisors(imgSize.y),\n        wideSide = Math.max(imgSize.x, imgSize.y),\n        common = _computeIntersection(divisorsX, divisorsY),\n        nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80],\n        nrOfPatchesMap = {\n            \"x-small\": 5,\n            \"small\": 4,\n            \"medium\": 3,\n            \"large\": 2,\n            \"x-large\": 1\n        },\n        nrOfPatchesIdx = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium,\n        nrOfPatches = nrOfPatchesList[nrOfPatchesIdx],\n        desiredPatchSize = Math.floor(wideSide / nrOfPatches),\n        optimalPatchSize;\n\n    function findPatchSizeForDivisors(divisors) {\n        var i = 0,\n            found = divisors[Math.floor(divisors.length / 2)];\n\n        while (i < (divisors.length - 1) && divisors[i] < desiredPatchSize) {\n            i++;\n        }\n        if (i > 0) {\n            if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {\n                found = divisors[i - 1];\n            } else {\n                found = divisors[i];\n            }\n        }\n        if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIdx + 1] / nrOfPatchesList[nrOfPatchesIdx] &&\n            desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIdx - 1] / nrOfPatchesList[nrOfPatchesIdx] ) {\n            return {x: found, y: found};\n        }\n        return null;\n    }\n\n    optimalPatchSize = findPatchSizeForDivisors(common);\n    if (!optimalPatchSize) {\n        optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(wideSide));\n        if (!optimalPatchSize) {\n            optimalPatchSize = findPatchSizeForDivisors((_computeDivisors(desiredPatchSize * nrOfPatches)));\n        }\n    }\n    return optimalPatchSize;\n};\n\nexport function _parseCSSDimensionValues(value) {\n    var dimension = {\n        value: parseFloat(value),\n        unit: value.indexOf(\"%\") === value.length - 1 ? \"%\" : \"%\"\n    };\n\n    return dimension;\n};\n\nexport const _dimensionsConverters = {\n    top: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.height * (dimension.value / 100));\n        }\n    },\n    right: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.width - (context.width * (dimension.value / 100)));\n        }\n    },\n    bottom: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.height - (context.height * (dimension.value / 100)));\n        }\n    },\n    left: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.width * (dimension.value / 100));\n        }\n    }\n};\n\nexport function computeImageArea(inputWidth, inputHeight, area) {\n    var context = {width: inputWidth, height: inputHeight};\n\n    var parsedArea = Object.keys(area).reduce(function(result, key) {\n        var value = area[key],\n            parsed = _parseCSSDimensionValues(value),\n            calculated = _dimensionsConverters[key](parsed, context);\n\n        result[key] = calculated;\n        return result;\n    }, {});\n\n    return {\n        sx: parsedArea.left,\n        sy: parsedArea.top,\n        sw: parsedArea.right - parsedArea.left,\n        sh: parsedArea.bottom - parsedArea.top\n    };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/cv_utils.js","import SubImage from './subImage';\nimport {hsv2rgb} from '../common/cv_utils';\nimport ArrayHelper from '../common/array_helper';\nconst vec2 = {\n    clone: require('gl-vec2/clone'),\n};\n\n/**\n * Represents a basic image combining the data and size.\n * In addition, some methods for manipulation are contained.\n * @param size {x,y} The size of the image in pixel\n * @param data {Array} If given, a flat array containing the pixel data\n * @param ArrayType {Type} If given, the desired DataType of the Array (may be typed/non-typed)\n * @param initialize {Boolean} Indicating if the array should be initialized on creation.\n * @returns {ImageWrapper}\n */\nfunction ImageWrapper(size, data, ArrayType, initialize) {\n    if (!data) {\n        if (ArrayType) {\n            this.data = new ArrayType(size.x * size.y);\n            if (ArrayType === Array && initialize) {\n                ArrayHelper.init(this.data, 0);\n            }\n        } else {\n            this.data = new Uint8Array(size.x * size.y);\n            if (Uint8Array === Array && initialize) {\n                ArrayHelper.init(this.data, 0);\n            }\n        }\n    } else {\n        this.data = data;\n    }\n    this.size = size;\n}\n\n/**\n * tests if a position is within the image with a given offset\n * @param imgRef {x, y} The location to test\n * @param border Number the padding value in pixel\n * @returns {Boolean} true if location inside the image's border, false otherwise\n * @see cvd/image.h\n */\nImageWrapper.prototype.inImageWithBorder = function(imgRef, border) {\n    return (imgRef.x >= border)\n        && (imgRef.y >= border)\n        && (imgRef.x < (this.size.x - border))\n        && (imgRef.y < (this.size.y - border));\n};\n\n/**\n * Performs bilinear sampling\n * @param inImg Image to extract sample from\n * @param x the x-coordinate\n * @param y the y-coordinate\n * @returns the sampled value\n * @see cvd/vision.h\n */\nImageWrapper.sample = function(inImg, x, y) {\n    var lx = Math.floor(x);\n    var ly = Math.floor(y);\n    var w = inImg.size.x;\n    var base = ly * inImg.size.x + lx;\n    var a = inImg.data[base + 0];\n    var b = inImg.data[base + 1];\n    var c = inImg.data[base + w];\n    var d = inImg.data[base + w + 1];\n    var e = a - b;\n    x -= lx;\n    y -= ly;\n\n    var result = Math.floor(x * (y * (e - c + d) - e) + y * (c - a) + a);\n    return result;\n};\n\n/**\n * Initializes a given array. Sets each element to zero.\n * @param array {Array} The array to initialize\n */\nImageWrapper.clearArray = function(array) {\n    var l = array.length;\n    while (l--) {\n        array[l] = 0;\n    }\n};\n\n/**\n * Creates a {SubImage} from the current image ({this}).\n * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)\n * @param size {ImageRef} The size of the resulting image\n * @returns {SubImage} A shared part of the original image\n */\nImageWrapper.prototype.subImage = function(from, size) {\n    return new SubImage(from, size, this);\n};\n\n/**\n * Creates an {ImageWrapper) and copies the needed underlying image-data area\n * @param imageWrapper {ImageWrapper} The target {ImageWrapper} where the data should be copied\n * @param from {ImageRef} The location where to copy from (top-left location)\n */\nImageWrapper.prototype.subImageAsCopy = function(imageWrapper, from) {\n    var sizeY = imageWrapper.size.y, sizeX = imageWrapper.size.x;\n    var x, y;\n    for ( x = 0; x < sizeX; x++) {\n        for ( y = 0; y < sizeY; y++) {\n            imageWrapper.data[y * sizeX + x] = this.data[(from.y + y) * this.size.x + from.x + x];\n        }\n    }\n};\n\nImageWrapper.prototype.copyTo = function(imageWrapper) {\n    var length = this.data.length, srcData = this.data, dstData = imageWrapper.data;\n\n    while (length--) {\n        dstData[length] = srcData[length];\n    }\n};\n\n/**\n * Retrieves a given pixel position from the image\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @returns {Number} The grayscale value at the pixel-position\n */\nImageWrapper.prototype.get = function(x, y) {\n    return this.data[y * this.size.x + x];\n};\n\n/**\n * Retrieves a given pixel position from the image\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @returns {Number} The grayscale value at the pixel-position\n */\nImageWrapper.prototype.getSafe = function(x, y) {\n    var i;\n\n    if (!this.indexMapping) {\n        this.indexMapping = {\n            x: [],\n            y: []\n        };\n        for (i = 0; i < this.size.x; i++) {\n            this.indexMapping.x[i] = i;\n            this.indexMapping.x[i + this.size.x] = i;\n        }\n        for (i = 0; i < this.size.y; i++) {\n            this.indexMapping.y[i] = i;\n            this.indexMapping.y[i + this.size.y] = i;\n        }\n    }\n    return this.data[(this.indexMapping.y[y + this.size.y]) * this.size.x + this.indexMapping.x[x + this.size.x]];\n};\n\n/**\n * Sets a given pixel position in the image\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @param value {Number} The grayscale value to set\n * @returns {ImageWrapper} The Image itself (for possible chaining)\n */\nImageWrapper.prototype.set = function(x, y, value) {\n    this.data[y * this.size.x + x] = value;\n    return this;\n};\n\n/**\n * Sets the border of the image (1 pixel) to zero\n */\nImageWrapper.prototype.zeroBorder = function() {\n    var i, width = this.size.x, height = this.size.y, data = this.data;\n    for ( i = 0; i < width; i++) {\n        data[i] = data[(height - 1) * width + i] = 0;\n    }\n    for ( i = 1; i < height - 1; i++) {\n        data[i * width] = data[i * width + (width - 1)] = 0;\n    }\n};\n\n/**\n * Inverts a binary image in place\n */\nImageWrapper.prototype.invert = function() {\n    var data = this.data, length = data.length;\n\n    while (length--) {\n        data[length] = data[length] ? 0 : 1;\n    }\n};\n\nImageWrapper.prototype.convolve = function(kernel) {\n    var x, y, kx, ky, kSize = (kernel.length / 2) | 0, accu = 0;\n    for ( y = 0; y < this.size.y; y++) {\n        for ( x = 0; x < this.size.x; x++) {\n            accu = 0;\n            for ( ky = -kSize; ky <= kSize; ky++) {\n                for ( kx = -kSize; kx <= kSize; kx++) {\n                    accu += kernel[ky + kSize][kx + kSize] * this.getSafe(x + kx, y + ky);\n                }\n            }\n            this.data[y * this.size.x + x] = accu;\n        }\n    }\n};\n\nImageWrapper.prototype.moments = function(labelcount) {\n    var data = this.data,\n        x,\n        y,\n        height = this.size.y,\n        width = this.size.x,\n        val,\n        ysq,\n        labelsum = [],\n        i,\n        label,\n        mu11,\n        mu02,\n        mu20,\n        x_,\n        y_,\n        tmp,\n        result = [],\n        PI = Math.PI,\n        PI_4 = PI / 4;\n\n    if (labelcount <= 0) {\n        return result;\n    }\n\n    for ( i = 0; i < labelcount; i++) {\n        labelsum[i] = {\n            m00: 0,\n            m01: 0,\n            m10: 0,\n            m11: 0,\n            m02: 0,\n            m20: 0,\n            theta: 0,\n            rad: 0\n        };\n    }\n\n    for ( y = 0; y < height; y++) {\n        ysq = y * y;\n        for ( x = 0; x < width; x++) {\n            val = data[y * width + x];\n            if (val > 0) {\n                label = labelsum[val - 1];\n                label.m00 += 1;\n                label.m01 += y;\n                label.m10 += x;\n                label.m11 += x * y;\n                label.m02 += ysq;\n                label.m20 += x * x;\n            }\n        }\n    }\n\n    for ( i = 0; i < labelcount; i++) {\n        label = labelsum[i];\n        if (!isNaN(label.m00) && label.m00 !== 0) {\n            x_ = label.m10 / label.m00;\n            y_ = label.m01 / label.m00;\n            mu11 = label.m11 / label.m00 - x_ * y_;\n            mu02 = label.m02 / label.m00 - y_ * y_;\n            mu20 = label.m20 / label.m00 - x_ * x_;\n            tmp = (mu02 - mu20) / (2 * mu11);\n            tmp = 0.5 * Math.atan(tmp) + (mu11 >= 0 ? PI_4 : -PI_4 ) + PI;\n            label.theta = (tmp * 180 / PI + 90) % 180 - 90;\n            if (label.theta < 0) {\n                label.theta += 180;\n            }\n            label.rad = tmp > PI ? tmp - PI : tmp;\n            label.vec = vec2.clone([Math.cos(tmp), Math.sin(tmp)]);\n            result.push(label);\n        }\n    }\n\n    return result;\n};\n\n/**\n * Displays the {ImageWrapper} in a given canvas\n * @param canvas {Canvas} The canvas element to write to\n * @param scale {Number} Scale which is applied to each pixel-value\n */\nImageWrapper.prototype.show = function(canvas, scale) {\n    var ctx,\n        frame,\n        data,\n        current,\n        pixel,\n        x,\n        y;\n\n    if (!scale) {\n        scale = 1.0;\n    }\n    ctx = canvas.getContext('2d');\n    canvas.width = this.size.x;\n    canvas.height = this.size.y;\n    frame = ctx.getImageData(0, 0, canvas.width, canvas.height);\n    data = frame.data;\n    current = 0;\n    for (y = 0; y < this.size.y; y++) {\n        for (x = 0; x < this.size.x; x++) {\n            pixel = y * this.size.x + x;\n            current = this.get(x, y) * scale;\n            data[pixel * 4 + 0] = current;\n            data[pixel * 4 + 1] = current;\n            data[pixel * 4 + 2] = current;\n            data[pixel * 4 + 3] = 255;\n        }\n    }\n    //frame.data = data;\n    ctx.putImageData(frame, 0, 0);\n};\n\n/**\n * Displays the {SubImage} in a given canvas\n * @param canvas {Canvas} The canvas element to write to\n * @param scale {Number} Scale which is applied to each pixel-value\n */\nImageWrapper.prototype.overlay = function(canvas, scale, from) {\n    if (!scale || scale < 0 || scale > 360) {\n        scale = 360;\n    }\n    var hsv = [0, 1, 1];\n    var rgb = [0, 0, 0];\n    var whiteRgb = [255, 255, 255];\n    var blackRgb = [0, 0, 0];\n    var result = [];\n    var ctx = canvas.getContext('2d');\n    var frame = ctx.getImageData(from.x, from.y, this.size.x, this.size.y);\n    var data = frame.data;\n    var length = this.data.length;\n    while (length--) {\n        hsv[0] = this.data[length] * scale;\n        result = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : hsv2rgb(hsv, rgb);\n        data[length * 4 + 0] = result[0];\n        data[length * 4 + 1] = result[1];\n        data[length * 4 + 2] = result[2];\n        data[length * 4 + 3] = 255;\n    }\n    ctx.putImageData(frame, from.x, from.y);\n};\n\nexport default ImageWrapper;\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/image_wrapper.js","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Map.js\n// module id = 27\n// module chunks = 0","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayPush.js\n// module id = 28\n// module chunks = 0","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_assignValue.js\n// module id = 29\n// module chunks = 0","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nmodule.exports = baseAssignValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseAssignValue.js\n// module id = 30\n// module chunks = 0","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneArrayBuffer.js\n// module id = 31\n// module chunks = 0","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getPrototype.js\n// module id = 32\n// module chunks = 0","var arrayFilter = require('./_arrayFilter'),\n    stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nmodule.exports = getSymbols;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getSymbols.js\n// module id = 33\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isPrototype.js\n// module id = 34\n// module chunks = 0","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isBuffer.js\n// module id = 35\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isFunction.js\n// module id = 36\n// module chunks = 0","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isLength.js\n// module id = 37\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isSymbol.js\n// module id = 38\n// module chunks = 0","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeys = require('./_baseKeys'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/keys.js\n// module id = 39\n// module chunks = 0","var baseMerge = require('./_baseMerge'),\n    createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\nmodule.exports = merge;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/merge.js\n// module id = 40\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 41\n// module chunks = 0","/**\n * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\nvar Tracer = {\n    searchDirections: [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]],\n    create: function(imageWrapper, labelWrapper) {\n        var imageData = imageWrapper.data,\n            labelData = labelWrapper.data,\n            searchDirections = this.searchDirections,\n            width = imageWrapper.size.x,\n            pos;\n\n        function trace(current, color, label, edgelabel) {\n            var i,\n                y,\n                x;\n\n            for ( i = 0; i < 7; i++) {\n                y = current.cy + searchDirections[current.dir][0];\n                x = current.cx + searchDirections[current.dir][1];\n                pos = y * width + x;\n                if ((imageData[pos] === color) && ((labelData[pos] === 0) || (labelData[pos] === label))) {\n                    labelData[pos] = label;\n                    current.cy = y;\n                    current.cx = x;\n                    return true;\n                } else {\n                    if (labelData[pos] === 0) {\n                        labelData[pos] = edgelabel;\n                    }\n                    current.dir = (current.dir + 1) % 8;\n                }\n            }\n            return false;\n        }\n\n        function vertex2D(x, y, dir) {\n            return {\n                dir: dir,\n                x: x,\n                y: y,\n                next: null,\n                prev: null\n            };\n        }\n\n        function contourTracing(sy, sx, label, color, edgelabel) {\n            var Fv = null,\n                Cv,\n                P,\n                ldir,\n                current = {\n                    cx: sx,\n                    cy: sy,\n                    dir: 0\n                };\n\n            if (trace(current, color, label, edgelabel)) {\n                Fv = vertex2D(sx, sy, current.dir);\n                Cv = Fv;\n                ldir = current.dir;\n                P = vertex2D(current.cx, current.cy, 0);\n                P.prev = Cv;\n                Cv.next = P;\n                P.next = null;\n                Cv = P;\n                do {\n                    current.dir = (current.dir + 6) % 8;\n                    trace(current, color, label, edgelabel);\n                    if (ldir !== current.dir) {\n                        Cv.dir = current.dir;\n                        P = vertex2D(current.cx, current.cy, 0);\n                        P.prev = Cv;\n                        Cv.next = P;\n                        P.next = null;\n                        Cv = P;\n                    } else {\n                        Cv.dir = ldir;\n                        Cv.x = current.cx;\n                        Cv.y = current.cy;\n                    }\n                    ldir = current.dir;\n                } while (current.cx !== sx || current.cy !== sy);\n                Fv.prev = Cv.prev;\n                Cv.prev.next = Fv;\n            }\n            return Fv;\n        }\n\n        return {\n            trace: function(current, color, label, edgelabel) {\n                return trace(current, color, label, edgelabel);\n            },\n            contourTracing: function(sy, sx, label, color, edgelabel) {\n                return contourTracing(sy, sx, label, color, edgelabel);\n            }\n        };\n    }\n};\n\nexport default (Tracer);\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/tracer.js","import BarcodeReader from './barcode_reader';\nimport ArrayHelper from '../common/array_helper';\n\nfunction Code39Reader() {\n    BarcodeReader.call(this);\n}\n\nvar properties = {\n    ALPHABETH_STRING: {value: \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%\"},\n    ALPHABET: {value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,\n        79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37]},\n    CHARACTER_ENCODINGS: {value: [0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049,\n        0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106,\n        0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A\n    ]},\n    ASTERISK: {value: 0x094},\n    FORMAT: {value: \"code_39\", writeable: false}\n};\n\nCode39Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nCode39Reader.prototype.constructor = Code39Reader;\n\nCode39Reader.prototype._toCounters = function(start, counter) {\n    var self = this,\n        numCounters = counter.length,\n        end = self._row.length,\n        isWhite = !self._row[start],\n        i,\n        counterPos = 0;\n\n    ArrayHelper.init(counter, 0);\n\n    for ( i = start; i < end; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            counterPos++;\n            if (counterPos === numCounters) {\n                break;\n            } else {\n                counter[counterPos] = 1;\n                isWhite = !isWhite;\n            }\n        }\n    }\n\n    return counter;\n};\n\nCode39Reader.prototype._decode = function() {\n    var self = this,\n        counters = [0, 0, 0, 0, 0, 0, 0, 0, 0],\n        result = [],\n        start = self._findStart(),\n        decodedChar,\n        lastStart,\n        pattern,\n        nextStart;\n\n    if (!start) {\n        return null;\n    }\n    nextStart = self._nextSet(self._row, start.end);\n\n    do {\n        counters = self._toCounters(nextStart, counters);\n        pattern = self._toPattern(counters);\n        if (pattern < 0) {\n            return null;\n        }\n        decodedChar = self._patternToChar(pattern);\n        if (decodedChar < 0){\n            return null;\n        }\n        result.push(decodedChar);\n        lastStart = nextStart;\n        nextStart += ArrayHelper.sum(counters);\n        nextStart = self._nextSet(self._row, nextStart);\n    } while (decodedChar !== '*');\n    result.pop();\n\n    if (!result.length) {\n        return null;\n    }\n\n    if (!self._verifyTrailingWhitespace(lastStart, nextStart, counters)) {\n        return null;\n    }\n\n    return {\n        code: result.join(\"\"),\n        start: start.start,\n        end: nextStart,\n        startInfo: start,\n        decodedCodes: result\n    };\n};\n\nCode39Reader.prototype._verifyTrailingWhitespace = function(lastStart, nextStart, counters) {\n    var trailingWhitespaceEnd,\n        patternSize = ArrayHelper.sum(counters);\n\n    trailingWhitespaceEnd = nextStart - lastStart - patternSize;\n    if ((trailingWhitespaceEnd * 3) >= patternSize) {\n        return true;\n    }\n    return false;\n};\n\nCode39Reader.prototype._patternToChar = function(pattern) {\n    var i,\n        self = this;\n\n    for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {\n        if (self.CHARACTER_ENCODINGS[i] === pattern) {\n            return String.fromCharCode(self.ALPHABET[i]);\n        }\n    }\n    return -1;\n};\n\nCode39Reader.prototype._findNextWidth = function(counters, current) {\n    var i,\n        minWidth = Number.MAX_VALUE;\n\n    for (i = 0; i < counters.length; i++) {\n        if (counters[i] < minWidth && counters[i] > current) {\n            minWidth = counters[i];\n        }\n    }\n\n    return minWidth;\n};\n\nCode39Reader.prototype._toPattern = function(counters) {\n    var numCounters = counters.length,\n        maxNarrowWidth = 0,\n        numWideBars = numCounters,\n        wideBarWidth = 0,\n        self = this,\n        pattern,\n        i;\n\n    while (numWideBars > 3) {\n        maxNarrowWidth = self._findNextWidth(counters, maxNarrowWidth);\n        numWideBars = 0;\n        pattern = 0;\n        for (i = 0; i < numCounters; i++) {\n            if (counters[i] > maxNarrowWidth) {\n                pattern |= 1 << (numCounters - 1 - i);\n                numWideBars++;\n                wideBarWidth += counters[i];\n            }\n        }\n\n        if (numWideBars === 3) {\n            for (i = 0; i < numCounters && numWideBars > 0; i++) {\n                if (counters[i] > maxNarrowWidth) {\n                    numWideBars--;\n                    if ((counters[i] * 2) >= wideBarWidth) {\n                        return -1;\n                    }\n                }\n            }\n            return pattern;\n        }\n    }\n    return -1;\n};\n\nCode39Reader.prototype._findStart = function() {\n    var self = this,\n        offset = self._nextSet(self._row),\n        patternStart = offset,\n        counter = [0, 0, 0, 0, 0, 0, 0, 0, 0],\n        counterPos = 0,\n        isWhite = false,\n        i,\n        j,\n        whiteSpaceMustStart;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                // find start pattern\n                if (self._toPattern(counter) === self.ASTERISK) {\n                    whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - ((i - patternStart) / 4)));\n                    if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                        return {\n                            start: patternStart,\n                            end: i\n                        };\n                    }\n                }\n\n                patternStart += counter[0] + counter[1];\n                for ( j = 0; j < 7; j++) {\n                    counter[j] = counter[j + 2];\n                }\n                counter[7] = 0;\n                counter[8] = 0;\n                counterPos--;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nexport default Code39Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_39_reader.js","module.exports = dot\n\n/**\n * Calculates the dot product of two vec2's\n *\n * @param {vec2} a the first operand\n * @param {vec2} b the second operand\n * @returns {Number} dot product of a and b\n */\nfunction dot(a, b) {\n    return a[0] * b[0] + a[1] * b[1]\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/dot.js\n// module id = 44\n// module chunks = 0","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_MapCache.js\n// module id = 45\n// module chunks = 0","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Stack.js\n// module id = 46\n// module chunks = 0","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayLikeKeys.js\n// module id = 47\n// module chunks = 0","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nmodule.exports = arrayMap;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayMap.js\n// module id = 48\n// module chunks = 0","/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  if (initAccum && length) {\n    accumulator = array[++index];\n  }\n  while (++index < length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\nmodule.exports = arrayReduce;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayReduce.js\n// module id = 49\n// module chunks = 0","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignMergeValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_assignMergeValue.js\n// module id = 50\n// module chunks = 0","var castPath = require('./_castPath'),\n    toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n  path = castPath(path, object);\n\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[toKey(path[index++])];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseGet.js\n// module id = 51\n// module chunks = 0","var arrayPush = require('./_arrayPush'),\n    isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseGetAllKeys.js\n// module id = 52\n// module chunks = 0","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneBuffer.js\n// module id = 53\n// module chunks = 0","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneTypedArray.js\n// module id = 54\n// module chunks = 0","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_copyArray.js\n// module id = 55\n// module chunks = 0","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_defineProperty.js\n// module id = 56\n// module chunks = 0","var flatten = require('./flatten'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\nfunction flatRest(func) {\n  return setToString(overRest(func, undefined, flatten), func + '');\n}\n\nmodule.exports = flatRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_flatRest.js\n// module id = 57\n// module chunks = 0","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_freeGlobal.js\n// module id = 58\n// module chunks = 0","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbolsIn = require('./_getSymbolsIn'),\n    keysIn = require('./keysIn');\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nmodule.exports = getAllKeysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getAllKeysIn.js\n// module id = 59\n// module chunks = 0","var arrayPush = require('./_arrayPush'),\n    getPrototype = require('./_getPrototype'),\n    getSymbols = require('./_getSymbols'),\n    stubArray = require('./stubArray');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\nmodule.exports = getSymbolsIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getSymbolsIn.js\n// module id = 60\n// module chunks = 0","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_initCloneObject.js\n// module id = 61\n// module chunks = 0","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_overArg.js\n// module id = 62\n// module chunks = 0","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nmodule.exports = overRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_overRest.js\n// module id = 63\n// module chunks = 0","var baseSetToString = require('./_baseSetToString'),\n    shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_setToString.js\n// module id = 64\n// module chunks = 0","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_toSource.js\n// module id = 65\n// module chunks = 0","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/identity.js\n// module id = 66\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    getPrototype = require('./_getPrototype'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isPlainObject.js\n// module id = 67\n// module chunks = 0","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isTypedArray.js\n// module id = 68\n// module chunks = 0","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = stubArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/stubArray.js\n// module id = 69\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 70\n// module chunks = 0","import TypeDefs from './common/typedefs'; // eslint-disable-line no-unused-vars\nimport WebrtcAdapter from 'webrtc-adapter'; // eslint-disable-line no-unused-vars\nimport ImageWrapper from './common/image_wrapper';\nimport BarcodeLocator from './locator/barcode_locator';\nimport BarcodeDecoder from './decoder/barcode_decoder';\nimport Events from './common/events';\nimport CameraAccess from './input/camera_access';\nimport ImageDebug from './common/image_debug';\nimport ResultCollector from './analytics/result_collector';\nimport Config from './config/config';\nimport InputStream from 'input_stream';\nimport FrameGrabber from 'frame_grabber';\nimport {merge} from 'lodash';\nconst vec2 = {\n    clone: require('gl-vec2/clone')\n};\n\nvar _inputStream,\n    _framegrabber,\n    _stopped,\n    _canvasContainer = {\n        ctx: {\n            image: null,\n            overlay: null\n        },\n        dom: {\n            image: null,\n            overlay: null\n        }\n    },\n    _inputImageWrapper,\n    _boxSize,\n    _decoder,\n    _workerPool = [],\n    _onUIThread = true,\n    _resultCollector,\n    _config = {};\n\nfunction initializeData(imageWrapper) {\n    initBuffers(imageWrapper);\n    _decoder = BarcodeDecoder.create(_config.decoder, _inputImageWrapper);\n}\n\nfunction initInputStream(cb) {\n    var video;\n    if (_config.inputStream.type === \"VideoStream\") {\n        video = document.createElement(\"video\");\n        _inputStream = InputStream.createVideoStream(video);\n    } else if (_config.inputStream.type === \"ImageStream\") {\n        _inputStream = InputStream.createImageStream();\n    } else if (_config.inputStream.type === \"LiveStream\") {\n        var $viewport = getViewPort();\n        if ($viewport) {\n            video = $viewport.querySelector(\"video\");\n            if (!video) {\n                video = document.createElement(\"video\");\n                $viewport.appendChild(video);\n            }\n        }\n        _inputStream = InputStream.createLiveStream(video);\n        CameraAccess.request(video, _config.inputStream.constraints)\n        .then(() => {\n            _inputStream.trigger(\"canrecord\");\n        }).catch((err) => {\n            return cb(err);\n        });\n    }\n\n    _inputStream.setAttribute(\"preload\", \"auto\");\n    _inputStream.setInputStream(_config.inputStream);\n    _inputStream.addEventListener(\"canrecord\", canRecord.bind(undefined, cb));\n}\n\nfunction getViewPort() {\n    var target = _config.inputStream.target;\n    // Check if target is already a DOM element\n    if (target && target.nodeName && target.nodeType === 1) {\n        return target;\n    } else {\n        // Use '#interactive.viewport' as a fallback selector (backwards compatibility)\n        var selector = typeof target === 'string' ? target : '#interactive.viewport';\n        return document.querySelector(selector);\n    }\n}\n\nfunction canRecord(cb) {\n    BarcodeLocator.checkImageConstraints(_inputStream, _config.locator);\n    initCanvas(_config);\n    _framegrabber = FrameGrabber.create(_inputStream, _canvasContainer.dom.image);\n\n    adjustWorkerPool(_config.numOfWorkers, function() {\n        if (_config.numOfWorkers === 0) {\n            initializeData();\n        }\n        ready(cb);\n    });\n}\n\nfunction ready(cb){\n    _inputStream.play();\n    cb();\n}\n\nfunction initCanvas() {\n    if (typeof document !== \"undefined\") {\n        var $viewport = getViewPort();\n        _canvasContainer.dom.image = document.querySelector(\"canvas.imgBuffer\");\n        if (!_canvasContainer.dom.image) {\n            _canvasContainer.dom.image = document.createElement(\"canvas\");\n            _canvasContainer.dom.image.className = \"imgBuffer\";\n            if ($viewport && _config.inputStream.type === \"ImageStream\") {\n                $viewport.appendChild(_canvasContainer.dom.image);\n            }\n        }\n        _canvasContainer.ctx.image = _canvasContainer.dom.image.getContext(\"2d\");\n        _canvasContainer.dom.image.width = _inputStream.getCanvasSize().x;\n        _canvasContainer.dom.image.height = _inputStream.getCanvasSize().y;\n\n        _canvasContainer.dom.overlay = document.querySelector(\"canvas.drawingBuffer\");\n        if (!_canvasContainer.dom.overlay) {\n            _canvasContainer.dom.overlay = document.createElement(\"canvas\");\n            _canvasContainer.dom.overlay.className = \"drawingBuffer\";\n            if ($viewport) {\n                $viewport.appendChild(_canvasContainer.dom.overlay);\n            }\n            var clearFix = document.createElement(\"br\");\n            clearFix.setAttribute(\"clear\", \"all\");\n            if ($viewport) {\n                $viewport.appendChild(clearFix);\n            }\n        }\n        _canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext(\"2d\");\n        _canvasContainer.dom.overlay.width = _inputStream.getCanvasSize().x;\n        _canvasContainer.dom.overlay.height = _inputStream.getCanvasSize().y;\n    }\n}\n\nfunction initBuffers(imageWrapper) {\n    if (imageWrapper) {\n        _inputImageWrapper = imageWrapper;\n    } else {\n        _inputImageWrapper = new ImageWrapper({\n            x: _inputStream.getWidth(),\n            y: _inputStream.getHeight()\n        });\n    }\n\n    if (ENV.development) {\n        console.log(_inputImageWrapper.size);\n    }\n    _boxSize = [\n        vec2.clone([0, 0]),\n        vec2.clone([0, _inputImageWrapper.size.y]),\n        vec2.clone([_inputImageWrapper.size.x, _inputImageWrapper.size.y]),\n        vec2.clone([_inputImageWrapper.size.x, 0])\n    ];\n    BarcodeLocator.init(_inputImageWrapper, _config.locator);\n}\n\nfunction getBoundingBoxes() {\n    if (_config.locate) {\n        return BarcodeLocator.locate();\n    } else {\n        return [[\n            vec2.clone(_boxSize[0]),\n            vec2.clone(_boxSize[1]),\n            vec2.clone(_boxSize[2]),\n            vec2.clone(_boxSize[3])]];\n    }\n}\n\nfunction transformResult(result) {\n    var topRight = _inputStream.getTopRight(),\n        xOffset = topRight.x,\n        yOffset = topRight.y,\n        i;\n\n    if (xOffset === 0 && yOffset === 0) {\n        return;\n    }\n\n    if (result.barcodes) {\n        for (i = 0; i < result.barcodes.length; i++) {\n            transformResult(result.barcodes[i]);\n        }\n    }\n\n    if (result.line && result.line.length === 2) {\n        moveLine(result.line);\n    }\n\n    if (result.box) {\n        moveBox(result.box);\n    }\n\n    if (result.boxes && result.boxes.length > 0) {\n        for (i = 0; i < result.boxes.length; i++) {\n            moveBox(result.boxes[i]);\n        }\n    }\n\n    function moveBox(box) {\n        var corner = box.length;\n\n        while (corner--) {\n            box[corner][0] += xOffset;\n            box[corner][1] += yOffset;\n        }\n    }\n\n    function moveLine(line) {\n        line[0].x += xOffset;\n        line[0].y += yOffset;\n        line[1].x += xOffset;\n        line[1].y += yOffset;\n    }\n}\n\nfunction addResult (result, imageData) {\n    if (!imageData || !_resultCollector) {\n        return;\n    }\n\n    if (result.barcodes) {\n        result.barcodes.filter(barcode => barcode.codeResult)\n            .forEach(barcode => addResult(barcode, imageData));\n    } else if (result.codeResult) {\n        _resultCollector.addResult(imageData, _inputStream.getCanvasSize(), result.codeResult);\n    }\n}\n\nfunction hasCodeResult (result) {\n    return result && (result.barcodes ?\n      result.barcodes.some(barcode => barcode.codeResult) :\n      result.codeResult);\n}\n\nfunction publishResult(result, imageData) {\n    let resultToPublish = result;\n\n    if (result && _onUIThread) {\n        transformResult(result);\n        addResult(result, imageData);\n        resultToPublish = result.barcodes || result;\n    }\n\n    Events.publish(\"processed\", resultToPublish);\n    if (hasCodeResult(result)) {\n        Events.publish(\"detected\", resultToPublish);\n    }\n}\n\nfunction locateAndDecode() {\n    var result,\n        boxes;\n\n    boxes = getBoundingBoxes();\n    if (boxes) {\n        result = _decoder.decodeFromBoundingBoxes(boxes);\n        result = result || {};\n        result.boxes = boxes;\n        publishResult(result, _inputImageWrapper.data);\n    } else {\n        publishResult();\n    }\n}\n\nfunction update() {\n    var availableWorker;\n\n    if (_onUIThread) {\n        if (_workerPool.length > 0) {\n            availableWorker = _workerPool.filter(function(workerThread) {\n                return !workerThread.busy;\n            })[0];\n            if (availableWorker) {\n                _framegrabber.attachData(availableWorker.imageData);\n            } else {\n                return; // all workers are busy\n            }\n        } else {\n            _framegrabber.attachData(_inputImageWrapper.data);\n        }\n        if (_framegrabber.grab()) {\n            if (availableWorker) {\n                availableWorker.busy = true;\n                availableWorker.worker.postMessage({\n                    cmd: 'process',\n                    imageData: availableWorker.imageData\n                }, [availableWorker.imageData.buffer]);\n            } else {\n                locateAndDecode();\n            }\n        }\n    } else {\n        locateAndDecode();\n    }\n}\n\nfunction startContinuousUpdate() {\n    var next = null,\n        delay = 1000 / (_config.frequency || 60);\n\n    _stopped = false;\n    (function frame(timestamp) {\n        next = next || timestamp;\n        if (!_stopped) {\n            if (timestamp >= next) {\n                next += delay;\n                update();\n            }\n            window.requestAnimFrame(frame);\n        }\n    }(performance.now()));\n}\n\nfunction start() {\n    if (_onUIThread && _config.inputStream.type === \"LiveStream\") {\n        startContinuousUpdate();\n    } else {\n        update();\n    }\n}\n\nfunction initWorker(cb) {\n    var blobURL,\n        workerThread = {\n            worker: undefined,\n            imageData: new Uint8Array(_inputStream.getWidth() * _inputStream.getHeight()),\n            busy: true\n        };\n\n    blobURL = generateWorkerBlob();\n    workerThread.worker = new Worker(blobURL);\n\n    workerThread.worker.onmessage = function(e) {\n        if (e.data.event === 'initialized') {\n            URL.revokeObjectURL(blobURL);\n            workerThread.busy = false;\n            workerThread.imageData = new Uint8Array(e.data.imageData);\n            if (ENV.development) {\n                console.log(\"Worker initialized\");\n            }\n            return cb(workerThread);\n        } else if (e.data.event === 'processed') {\n            workerThread.imageData = new Uint8Array(e.data.imageData);\n            workerThread.busy = false;\n            publishResult(e.data.result, workerThread.imageData);\n        } else if (e.data.event === 'error') {\n            if (ENV.development) {\n                console.log(\"Worker error: \" + e.data.message);\n            }\n        }\n    };\n\n    workerThread.worker.postMessage({\n        cmd: 'init',\n        size: {x: _inputStream.getWidth(), y: _inputStream.getHeight()},\n        imageData: workerThread.imageData,\n        config: configForWorker(_config)\n    }, [workerThread.imageData.buffer]);\n}\n\nfunction configForWorker(config) {\n    return {\n        ...config,\n        inputStream: {\n            ...config.inputStream,\n            target: null\n        }\n    };\n}\n\nfunction workerInterface(factory) {\n    /* eslint-disable no-undef*/\n    if (factory) {\n        var Quagga = factory().default;\n        if (!Quagga) {\n            self.postMessage({'event': 'error', message: 'Quagga could not be created'});\n            return;\n        }\n    }\n    var imageWrapper;\n\n    self.onmessage = function(e) {\n        if (e.data.cmd === 'init') {\n            var config = e.data.config;\n            config.numOfWorkers = 0;\n            imageWrapper = new Quagga.ImageWrapper({\n                x: e.data.size.x,\n                y: e.data.size.y\n            }, new Uint8Array(e.data.imageData));\n            Quagga.init(config, ready, imageWrapper);\n            Quagga.onProcessed(onProcessed);\n        } else if (e.data.cmd === 'process') {\n            imageWrapper.data = new Uint8Array(e.data.imageData);\n            Quagga.start();\n        } else if (e.data.cmd === 'setReaders') {\n            Quagga.setReaders(e.data.readers);\n        }\n    };\n\n    function onProcessed(result) {\n        self.postMessage({\n            'event': 'processed',\n            imageData: imageWrapper.data,\n            result: result\n        }, [imageWrapper.data.buffer]);\n    }\n\n    function ready() { // eslint-disable-line\n        self.postMessage({'event': 'initialized', imageData: imageWrapper.data}, [imageWrapper.data.buffer]);\n    }\n\n    /* eslint-enable */\n}\n\nfunction generateWorkerBlob() {\n    var blob,\n        factorySource;\n\n    /* jshint ignore:start */\n    if (typeof __factorySource__ !== 'undefined') {\n        factorySource = __factorySource__; // eslint-disable-line no-undef\n    }\n    /* jshint ignore:end */\n\n    blob = new Blob(['(' + workerInterface.toString() + ')(' + factorySource + ');'],\n        {type: 'text/javascript'});\n\n    return window.URL.createObjectURL(blob);\n}\n\nfunction setReaders(readers) {\n    if (_decoder) {\n        _decoder.setReaders(readers);\n    } else if (_onUIThread && _workerPool.length > 0) {\n        _workerPool.forEach(function(workerThread) {\n            workerThread.worker.postMessage({cmd: 'setReaders', readers: readers});\n        });\n    }\n}\n\nfunction adjustWorkerPool(capacity, cb) {\n    const increaseBy = capacity - _workerPool.length;\n    if (increaseBy === 0) {\n        return cb && cb();\n    }\n    if (increaseBy < 0) {\n        const workersToTerminate = _workerPool.slice(increaseBy);\n        workersToTerminate.forEach(function(workerThread) {\n            workerThread.worker.terminate();\n            if (ENV.development) {\n                console.log(\"Worker terminated!\");\n            }\n        });\n        _workerPool = _workerPool.slice(0, increaseBy);\n        return cb && cb();\n    } else {\n        for (var i = 0; i < increaseBy; i++) {\n            initWorker(workerInitialized);\n        }\n\n        function workerInitialized(workerThread) {\n            _workerPool.push(workerThread);\n            if (_workerPool.length >= capacity){\n                cb && cb();\n            }\n        }\n    }\n}\n\nexport default {\n    init: function(config, cb, imageWrapper) {\n        _config = merge({}, Config, config);\n        if (imageWrapper) {\n            _onUIThread = false;\n            initializeData(imageWrapper);\n            return cb();\n        } else {\n            initInputStream(cb);\n        }\n    },\n    start: function() {\n        start();\n    },\n    stop: function() {\n        _stopped = true;\n        adjustWorkerPool(0);\n        if (_config.inputStream.type === \"LiveStream\") {\n            CameraAccess.release();\n            _inputStream.clearEventHandlers();\n        }\n    },\n    pause: function() {\n        _stopped = true;\n    },\n    onDetected: function(callback) {\n        Events.subscribe(\"detected\", callback);\n    },\n    offDetected: function(callback) {\n        Events.unsubscribe(\"detected\", callback);\n    },\n    onProcessed: function(callback) {\n        Events.subscribe(\"processed\", callback);\n    },\n    offProcessed: function(callback) {\n        Events.unsubscribe(\"processed\", callback);\n    },\n    setReaders: function(readers) {\n        setReaders(readers);\n    },\n    registerResultCollector: function(resultCollector) {\n        if (resultCollector && typeof resultCollector.addResult === 'function') {\n            _resultCollector = resultCollector;\n        }\n    },\n    canvas: _canvasContainer,\n    decodeSingle: function(config, resultCallback) {\n        config = merge({\n            inputStream: {\n                type: \"ImageStream\",\n                sequence: false,\n                size: 800,\n                src: config.src\n            },\n            numOfWorkers: (ENV.development && config.debug) ? 0 : 1,\n            locator: {\n                halfSample: false\n            }\n        }, config);\n        this.init(config, () => {\n            Events.once(\"processed\", (result) => {\n                this.stop();\n                resultCallback.call(null, result);\n            }, true);\n            start();\n        });\n    },\n    ImageWrapper: ImageWrapper,\n    ImageDebug: ImageDebug,\n    ResultCollector: ResultCollector,\n    CameraAccess: CameraAccess,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/quagga.js","const CVUtils = require('../src/common/cv_utils'),\n      Ndarray = require(\"ndarray\"),\n      Interp2D = require(\"ndarray-linear-interpolate\").d2;\n\nvar FrameGrabber = {};\n\nFrameGrabber.create = function(inputStream) {\n    var _that = {},\n        _streamConfig = inputStream.getConfig(),\n        _video_size = CVUtils.imageRef(inputStream.getRealWidth(), inputStream.getRealHeight()),\n        _canvasSize = inputStream.getCanvasSize(),\n        _size = CVUtils.imageRef(inputStream.getWidth(), inputStream.getHeight()),\n        _topRight = inputStream.getTopRight(),\n        _data = new Uint8Array(_size.x * _size.y),\n        _grayData = new Uint8Array(_video_size.x * _video_size.y),\n        _canvasData = new Uint8Array(_canvasSize.x * _canvasSize.y),\n        _grayImageArray = Ndarray(_grayData, [_video_size.y, _video_size.x]).transpose(1, 0),\n        _canvasImageArray = Ndarray(_canvasData, [_canvasSize.y, _canvasSize.x]).transpose(1, 0),\n        _targetImageArray = _canvasImageArray.hi(_topRight.x + _size.x, _topRight.y + _size.y).lo(_topRight.x, _topRight.y),\n        _stepSizeX = _video_size.x/_canvasSize.x,\n        _stepSizeY = _video_size.y/_canvasSize.y;\n\n    console.log(\"FrameGrabber\", JSON.stringify({\n        videoSize: _grayImageArray.shape,\n        canvasSize: _canvasImageArray.shape,\n        stepSize: [_stepSizeX, _stepSizeY],\n        size: _targetImageArray.shape,\n        topRight: _topRight\n    }));\n\n    /**\n     * Uses the given array as frame-buffer\n     */\n    _that.attachData = function(data) {\n        _data = data;\n    };\n\n    /**\n     * Returns the used frame-buffer\n     */\n    _that.getData = function() {\n        return _data;\n    };\n\n    /**\n     * Fetches a frame from the input-stream and puts into the frame-buffer.\n     * The image-data is converted to gray-scale and then half-sampled if configured.\n     */\n    _that.grab = function() {\n        var frame = inputStream.getFrame();\n\n        if (frame) {\n            this.scaleAndCrop(frame);\n            return true;\n        } else {\n            return false;\n        }\n    };\n\n    _that.scaleAndCrop = function(frame) {\n        var x,\n            y;\n\n        // 1. compute full-sized gray image\n        CVUtils.computeGray(frame.data, _grayData);\n\n        // 2. interpolate\n        for (y = 0; y < _canvasSize.y; y++) {\n            for (x = 0; x < _canvasSize.x; x++) {\n                _canvasImageArray.set(x, y, (Interp2D(_grayImageArray, x * _stepSizeX, y * _stepSizeY)) | 0);\n            }\n        }\n\n        // targetImageArray must be equal to targetSize\n        if (_targetImageArray.shape[0] !== _size.x ||\n            _targetImageArray.shape[1] !== _size.y) {\n            throw new Error(\"Shapes do not match!\");\n        }\n\n        // 3. crop\n        for (y = 0; y < _size.y; y++) {\n            for (x = 0; x < _size.x; x++) {\n                _data[y * _size.x + x] = _targetImageArray.get(x, y);\n            }\n        }\n    },\n\n    _that.getSize = function() {\n        return _size;\n    };\n\n    return _that;\n};\n\nmodule.exports = FrameGrabber;\n\n\n\n// WEBPACK FOOTER //\n// ./lib/frame_grabber.js","const GetPixels = require(\"get-pixels\");\n\nvar InputStream = {};\n\nInputStream.createImageStream = function() {\n    var that = {};\n    var _config = null;\n\n    var width = 0,\n        height = 0,\n        frameIdx = 0,\n        paused = true,\n        loaded = false,\n        frame = null,\n        baseUrl,\n        ended = false,\n        size,\n        calculatedWidth,\n        calculatedHeight,\n        _eventNames = ['canrecord', 'ended'],\n        _eventHandlers = {},\n        _topRight = {x: 0, y: 0},\n        _canvasSize = {x: 0, y: 0};\n\n    function loadImages() {\n        loaded = false;\n        GetPixels(baseUrl, function(err, pixels) {\n            if (err) {\n                console.log(err);\n                exit(1);\n            }\n            loaded = true;\n            console.log(pixels.shape);\n            frame = pixels;\n            width = pixels.shape[0];\n            height = pixels.shape[1];\n            calculatedWidth = _config.size ? width/height > 1 ? _config.size : Math.floor((width/height) * _config.size) : width;\n            calculatedHeight = _config.size ? width/height > 1 ? Math.floor((height/width) * _config.size) : _config.size : height;\n\n            _canvasSize.x = calculatedWidth;\n            _canvasSize.y = calculatedHeight;\n\n            setTimeout(function() {\n                publishEvent(\"canrecord\", []);\n            }, 0);\n        });\n    }\n\n    function publishEvent(eventName, args) {\n        var j,\n            handlers = _eventHandlers[eventName];\n\n        if (handlers && handlers.length > 0) {\n            for ( j = 0; j < handlers.length; j++) {\n                handlers[j].apply(that, args);\n            }\n        }\n    }\n\n\n    that.trigger = publishEvent;\n\n    that.getWidth = function() {\n        return calculatedWidth;\n    };\n\n    that.getHeight = function() {\n        return calculatedHeight;\n    };\n\n    that.setWidth = function(width) {\n        calculatedWidth = width;\n    };\n\n    that.setHeight = function(height) {\n        calculatedHeight = height;\n    };\n\n    that.getRealWidth = function() {\n        return width;\n    };\n\n    that.getRealHeight = function() {\n        return height;\n    };\n\n    that.setInputStream = function(stream) {\n        _config = stream;\n        baseUrl = _config.src;\n        size = 1;\n        loadImages();\n    };\n\n    that.ended = function() {\n        return ended;\n    };\n\n    that.setAttribute = function() {};\n\n    that.getConfig = function() {\n        return _config;\n    };\n\n    that.pause = function() {\n        paused = true;\n    };\n\n    that.play = function() {\n        paused = false;\n    };\n\n    that.setCurrentTime = function(time) {\n        frameIdx = time;\n    };\n\n    that.addEventListener = function(event, f) {\n        if (_eventNames.indexOf(event) !== -1) {\n            if (!_eventHandlers[event]) {\n                _eventHandlers[event] = [];\n            }\n            _eventHandlers[event].push(f);\n        }\n    };\n\n    that.setTopRight = function(topRight) {\n        _topRight.x = topRight.x;\n        _topRight.y = topRight.y;\n    };\n\n    that.getTopRight = function() {\n        return _topRight;\n    };\n\n    that.setCanvasSize = function(size) {\n        _canvasSize.x = size.x;\n        _canvasSize.y = size.y;\n    };\n\n    that.getCanvasSize = function() {\n        return _canvasSize;\n    };\n\n    that.getFrame = function() {\n        if (!loaded){\n            return null;\n        }\n        return frame;\n    };\n\n    return that;\n};\n\nmodule.exports = InputStream;\n\n\n\n// WEBPACK FOOTER //\n// ./lib/input_stream.js","import ImageDebug from '../common/image_debug';\n\nfunction contains(codeResult, list) {\n    if (list) {\n        return list.some(function (item) {\n            return Object.keys(item).every(function (key) {\n                return item[key] === codeResult[key];\n            });\n        });\n    }\n    return false;\n}\n\nfunction passesFilter(codeResult, filter) {\n    if (typeof filter === 'function') {\n        return filter(codeResult);\n    }\n    return true;\n}\n\nexport default {\n    create: function(config) {\n        var canvas = document.createElement(\"canvas\"),\n            ctx = canvas.getContext(\"2d\"),\n            results = [],\n            capacity = config.capacity || 20,\n            capture = config.capture === true;\n\n        function matchesConstraints(codeResult) {\n            return capacity\n                && codeResult\n                && !contains(codeResult, config.blacklist)\n                && passesFilter(codeResult, config.filter);\n        }\n\n        return {\n            addResult: function(data, imageSize, codeResult) {\n                var result = {};\n\n                if (matchesConstraints(codeResult)) {\n                    capacity--;\n                    result.codeResult = codeResult;\n                    if (capture) {\n                        canvas.width = imageSize.x;\n                        canvas.height = imageSize.y;\n                        ImageDebug.drawImage(data, imageSize, ctx);\n                        result.frame = canvas.toDataURL();\n                    }\n                    results.push(result);\n                }\n            },\n            getResults: function() {\n                return results;\n            }\n        };\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/analytics/result_collector.js","const vec2 = {\n    clone: require('gl-vec2/clone'),\n    dot: require('gl-vec2/dot')\n}\n    /**\n     * Creates a cluster for grouping similar orientations of datapoints\n     */\nexport default {\n    create: function(point, threshold) {\n        var points = [],\n            center = {\n                rad: 0,\n                vec: vec2.clone([0, 0])\n            },\n            pointMap = {};\n\n        function init() {\n            add(point);\n            updateCenter();\n        }\n\n        function add(pointToAdd) {\n            pointMap[pointToAdd.id] = pointToAdd;\n            points.push(pointToAdd);\n        }\n\n        function updateCenter() {\n            var i, sum = 0;\n            for ( i = 0; i < points.length; i++) {\n                sum += points[i].rad;\n            }\n            center.rad = sum / points.length;\n            center.vec = vec2.clone([Math.cos(center.rad), Math.sin(center.rad)]);\n        }\n\n        init();\n\n        return {\n            add: function(pointToAdd) {\n                if (!pointMap[pointToAdd.id]) {\n                    add(pointToAdd);\n                    updateCenter();\n                }\n            },\n            fits: function(otherPoint) {\n                // check cosine similarity to center-angle\n                var similarity = Math.abs(vec2.dot(otherPoint.point.vec, center.vec));\n                if (similarity > threshold) {\n                    return true;\n                }\n                return false;\n            },\n            getPoints: function() {\n                return points;\n            },\n            getCenter: function() {\n                return center;\n            }\n        };\n    },\n    createPoint: function(newPoint, id, property) {\n        return {\n            rad: newPoint[property],\n            point: newPoint,\n            id: id\n        };\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/cluster.js","export default (function() {\n    var events = {};\n\n    function getEvent(eventName) {\n        if (!events[eventName]) {\n            events[eventName] = {\n                subscribers: []\n            };\n        }\n        return events[eventName];\n    }\n\n    function clearEvents(){\n        events = {};\n    }\n\n    function publishSubscription(subscription, data) {\n        if (subscription.async) {\n            setTimeout(function() {\n                subscription.callback(data);\n            }, 4);\n        } else {\n            subscription.callback(data);\n        }\n    }\n\n    function subscribe(event, callback, async) {\n        var subscription;\n\n        if ( typeof callback === \"function\") {\n            subscription = {\n                callback: callback,\n                async: async\n            };\n        } else {\n            subscription = callback;\n            if (!subscription.callback) {\n                throw \"Callback was not specified on options\";\n            }\n        }\n\n        getEvent(event).subscribers.push(subscription);\n    }\n\n    return {\n        subscribe: function(event, callback, async) {\n            return subscribe(event, callback, async);\n        },\n        publish: function(eventName, data) {\n            var event = getEvent(eventName),\n                subscribers = event.subscribers;\n\n            // Publish one-time subscriptions\n            subscribers.filter(function(subscriber) {\n                return !!subscriber.once;\n            }).forEach((subscriber) => {\n                publishSubscription(subscriber, data);\n            });\n\n            // remove them from the subscriber\n            event.subscribers = subscribers.filter(function(subscriber) {\n                return !subscriber.once;\n            });\n\n            // publish the rest\n            event.subscribers.forEach((subscriber) => {\n                publishSubscription(subscriber, data);\n            });\n        },\n        once: function(event, callback, async) {\n            subscribe(event, {\n                callback: callback,\n                async: async,\n                once: true\n            });\n        },\n        unsubscribe: function(eventName, callback) {\n            var event;\n\n            if (eventName) {\n                event = getEvent(eventName);\n                if (event && callback) {\n                    event.subscribers = event.subscribers.filter(function(subscriber){\n                        return subscriber.callback !== callback;\n                    });\n                } else {\n                    event.subscribers = [];\n                }\n            } else {\n                clearEvents();\n            }\n        }\n    };\n})();\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/events.js","\nexport function enumerateDevices() {\n    if (navigator.mediaDevices\n            && typeof navigator.mediaDevices.enumerateDevices === 'function') {\n        return navigator.mediaDevices.enumerateDevices();\n    }\n    return Promise.reject(new Error('enumerateDevices is not defined'));\n};\n\nexport function getUserMedia(constraints) {\n    if (navigator.mediaDevices\n            && typeof navigator.mediaDevices.getUserMedia === 'function') {\n        return navigator.mediaDevices\n            .getUserMedia(constraints);\n    }\n    return Promise.reject(new Error('getUserMedia is not defined'));\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/mediaDevices.js","/**\n * Construct representing a part of another {ImageWrapper}. Shares data\n * between the parent and the child.\n * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)\n * @param size {ImageRef} The size of the resulting image\n * @param I {ImageWrapper} The {ImageWrapper} to share from\n * @returns {SubImage} A shared part of the original image\n */\nfunction SubImage(from, size, I) {\n    if (!I) {\n        I = {\n            data: null,\n            size: size\n        };\n    }\n    this.data = I.data;\n    this.originalSize = I.size;\n    this.I = I;\n\n    this.from = from;\n    this.size = size;\n}\n\n/**\n * Displays the {SubImage} in a given canvas\n * @param canvas {Canvas} The canvas element to write to\n * @param scale {Number} Scale which is applied to each pixel-value\n */\nSubImage.prototype.show = function(canvas, scale) {\n    var ctx,\n        frame,\n        data,\n        current,\n        y,\n        x,\n        pixel;\n\n    if (!scale) {\n        scale = 1.0;\n    }\n    ctx = canvas.getContext('2d');\n    canvas.width = this.size.x;\n    canvas.height = this.size.y;\n    frame = ctx.getImageData(0, 0, canvas.width, canvas.height);\n    data = frame.data;\n    current = 0;\n    for (y = 0; y < this.size.y; y++) {\n        for (x = 0; x < this.size.x; x++) {\n            pixel = y * this.size.x + x;\n            current = this.get(x, y) * scale;\n            data[pixel * 4 + 0] = current;\n            data[pixel * 4 + 1] = current;\n            data[pixel * 4 + 2] = current;\n            data[pixel * 4 + 3] = 255;\n        }\n    }\n    frame.data = data;\n    ctx.putImageData(frame, 0, 0);\n};\n\n/**\n * Retrieves a given pixel position from the {SubImage}\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @returns {Number} The grayscale value at the pixel-position\n */\nSubImage.prototype.get = function(x, y) {\n    return this.data[(this.from.y + y) * this.originalSize.x + this.from.x + x];\n};\n\n/**\n * Updates the underlying data from a given {ImageWrapper}\n * @param image {ImageWrapper} The updated image\n */\nSubImage.prototype.updateData = function(image) {\n    this.originalSize = image.size;\n    this.data = image.data;\n};\n\n/**\n * Updates the position of the shared area\n * @param from {x,y} The new location\n * @returns {SubImage} returns {this} for possible chaining\n */\nSubImage.prototype.updateFrom = function(from) {\n    this.from = from;\n    return this;\n};\n\nexport default (SubImage);\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/subImage.js","/*\n * typedefs.js\n * Normalizes browser-specific prefixes\n */\n\nif (typeof window !== 'undefined') {\n    window.requestAnimFrame = (function () {\n        return window.requestAnimationFrame ||\n            window.webkitRequestAnimationFrame ||\n            window.mozRequestAnimationFrame ||\n            window.oRequestAnimationFrame ||\n            window.msRequestAnimationFrame ||\n            function (/* function FrameRequestCallback */ callback) {\n                window.setTimeout(callback, 1000 / 60);\n            };\n    })();\n}\nMath.imul = Math.imul || function(a, b) {\n    var ah = (a >>> 16) & 0xffff,\n        al = a & 0xffff,\n        bh = (b >>> 16) & 0xffff,\n        bl = b & 0xffff;\n    // the shift by 0 fixes the sign on the high part\n    // the final |0 converts the unsigned value into a signed value\n    return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0);\n};\n\nif (typeof Object.assign !== 'function') {\n    Object.assign = function(target) { // .length of function is 2\n        'use strict';\n        if (target === null) { // TypeError if undefined or null\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var to = Object(target);\n\n        for (var index = 1; index < arguments.length; index++) {\n            var nextSource = arguments[index];\n\n            if (nextSource !== null) { // Skip over if undefined or null\n                for (var nextKey in nextSource) {\n                    // Avoid bugs when hasOwnProperty is shadowed\n                    if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {\n                        to[nextKey] = nextSource[nextKey];\n                    }\n                }\n            }\n        }\n        return to;\n    };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/typedefs.js","let config;\n\nif (ENV.development){\n    config = require('./config.dev.js');\n} else if (ENV.node) {\n    config = require('./config.node.js');\n} else {\n    config = require('./config.prod.js');\n}\n\nexport default config;\n\n\n\n// WEBPACK FOOTER //\n// ./src/config/config.js","module.exports = {\n    inputStream: {\n        type: \"ImageStream\",\n        sequence: false,\n        size: 800,\n        area: {\n            top: \"0%\",\n            right: \"0%\",\n            left: \"0%\",\n            bottom: \"0%\"\n        },\n        singleChannel: false // true: only the red color-channel is read\n    },\n    locate: true,\n    numOfWorkers: 0,\n    decoder: {\n        readers: [\n            'code_128_reader'\n        ]\n    },\n    locator: {\n        halfSample: true,\n        patchSize: \"medium\" // x-small, small, medium, large, x-large\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/config/config.node.js","import Bresenham from './bresenham';\nimport ImageDebug from '../common/image_debug';\nimport Code128Reader from '../reader/code_128_reader';\nimport EANReader from '../reader/ean_reader';\nimport Code39Reader from '../reader/code_39_reader';\nimport Code39VINReader from '../reader/code_39_vin_reader';\nimport CodabarReader from '../reader/codabar_reader';\nimport UPCReader from '../reader/upc_reader';\nimport EAN8Reader from '../reader/ean_8_reader';\nimport EAN2Reader from '../reader/ean_2_reader';\nimport EAN5Reader from '../reader/ean_5_reader';\nimport UPCEReader from '../reader/upc_e_reader';\nimport I2of5Reader from '../reader/i2of5_reader';\n\nconst READERS = {\n    code_128_reader: Code128Reader,\n    ean_reader: EANReader,\n    ean_5_reader: EAN5Reader,\n    ean_2_reader: EAN2Reader,\n    ean_8_reader: EAN8Reader,\n    code_39_reader: Code39Reader,\n    code_39_vin_reader: Code39VINReader,\n    codabar_reader: CodabarReader,\n    upc_reader: UPCReader,\n    upc_e_reader: UPCEReader,\n    i2of5_reader: I2of5Reader\n};\nexport default {\n    create: function(config, inputImageWrapper) {\n        var _canvas = {\n                ctx: {\n                    frequency: null,\n                    pattern: null,\n                    overlay: null\n                },\n                dom: {\n                    frequency: null,\n                    pattern: null,\n                    overlay: null\n                }\n            },\n            _barcodeReaders = [];\n\n        initCanvas();\n        initReaders();\n        initConfig();\n\n        function initCanvas() {\n            if (ENV.development && typeof document !== 'undefined') {\n                var $debug = document.querySelector(\"#debug.detection\");\n                _canvas.dom.frequency = document.querySelector(\"canvas.frequency\");\n                if (!_canvas.dom.frequency) {\n                    _canvas.dom.frequency = document.createElement(\"canvas\");\n                    _canvas.dom.frequency.className = \"frequency\";\n                    if ($debug) {\n                        $debug.appendChild(_canvas.dom.frequency);\n                    }\n                }\n                _canvas.ctx.frequency = _canvas.dom.frequency.getContext(\"2d\");\n\n                _canvas.dom.pattern = document.querySelector(\"canvas.patternBuffer\");\n                if (!_canvas.dom.pattern) {\n                    _canvas.dom.pattern = document.createElement(\"canvas\");\n                    _canvas.dom.pattern.className = \"patternBuffer\";\n                    if ($debug) {\n                        $debug.appendChild(_canvas.dom.pattern);\n                    }\n                }\n                _canvas.ctx.pattern = _canvas.dom.pattern.getContext(\"2d\");\n\n                _canvas.dom.overlay = document.querySelector(\"canvas.drawingBuffer\");\n                if (_canvas.dom.overlay) {\n                    _canvas.ctx.overlay = _canvas.dom.overlay.getContext(\"2d\");\n                }\n            }\n        }\n\n        function initReaders() {\n            config.readers.forEach(function(readerConfig) {\n                var reader,\n                    configuration = {},\n                    supplements = [];\n\n                if (typeof readerConfig === 'object') {\n                    reader = readerConfig.format;\n                    configuration = readerConfig.config;\n                } else if (typeof readerConfig === 'string') {\n                    reader = readerConfig;\n                }\n                if (ENV.development) {\n                    console.log(\"Before registering reader: \", reader);\n                }\n                if (configuration.supplements) {\n                    supplements = configuration\n                        .supplements.map((supplement) => {\n                            return new READERS[supplement]();\n                        });\n                }\n                _barcodeReaders.push(new READERS[reader](configuration, supplements));\n            });\n            if (ENV.development) {\n                console.log(\"Registered Readers: \" + _barcodeReaders\n                    .map((reader) => JSON.stringify({format: reader.FORMAT, config: reader.config}))\n                    .join(', '));\n            }\n        }\n\n        function initConfig() {\n            if (ENV.development && typeof document !== 'undefined') {\n                var i,\n                    vis = [{\n                        node: _canvas.dom.frequency,\n                        prop: config.debug.showFrequency\n                    }, {\n                        node: _canvas.dom.pattern,\n                        prop: config.debug.showPattern\n                    }];\n\n                for (i = 0; i < vis.length; i++) {\n                    if (vis[i].prop === true) {\n                        vis[i].node.style.display = \"block\";\n                    } else {\n                        vis[i].node.style.display = \"none\";\n                    }\n                }\n            }\n        }\n\n        /**\n         * extend the line on both ends\n         * @param {Array} line\n         * @param {Number} angle\n         */\n        function getExtendedLine(line, angle, ext) {\n            function extendLine(amount) {\n                var extension = {\n                    y: amount * Math.sin(angle),\n                    x: amount * Math.cos(angle)\n                };\n\n                line[0].y -= extension.y;\n                line[0].x -= extension.x;\n                line[1].y += extension.y;\n                line[1].x += extension.x;\n            }\n\n            // check if inside image\n            extendLine(ext);\n            while (ext > 1 && (!inputImageWrapper.inImageWithBorder(line[0], 0)\n                    || !inputImageWrapper.inImageWithBorder(line[1], 0))) {\n                ext -= Math.ceil(ext / 2);\n                extendLine(-ext);\n            }\n            return line;\n        }\n\n        function getLine(box) {\n            return [{\n                x: (box[1][0] - box[0][0]) / 2 + box[0][0],\n                y: (box[1][1] - box[0][1]) / 2 + box[0][1]\n            }, {\n                x: (box[3][0] - box[2][0]) / 2 + box[2][0],\n                y: (box[3][1] - box[2][1]) / 2 + box[2][1]\n            }];\n        }\n\n        function tryDecode(line) {\n            var result = null,\n                i,\n                barcodeLine = Bresenham.getBarcodeLine(inputImageWrapper, line[0], line[1]);\n\n            if (ENV.development && config.debug.showFrequency) {\n                ImageDebug.drawPath(line, {x: 'x', y: 'y'}, _canvas.ctx.overlay, {color: 'red', lineWidth: 3});\n                Bresenham.debug.printFrequency(barcodeLine.line, _canvas.dom.frequency);\n            }\n\n            Bresenham.toBinaryLine(barcodeLine);\n\n            if (ENV.development && config.debug.showPattern) {\n                Bresenham.debug.printPattern(barcodeLine.line, _canvas.dom.pattern);\n            }\n\n            for ( i = 0; i < _barcodeReaders.length && result === null; i++) {\n                result = _barcodeReaders[i].decodePattern(barcodeLine.line);\n            }\n            if (result === null){\n                return null;\n            }\n            return {\n                codeResult: result,\n                barcodeLine: barcodeLine\n            };\n        }\n\n        /**\n         * This method slices the given area apart and tries to detect a barcode-pattern\n         * for each slice. It returns the decoded barcode, or null if nothing was found\n         * @param {Array} box\n         * @param {Array} line\n         * @param {Number} lineAngle\n         */\n        function tryDecodeBruteForce(box, line, lineAngle) {\n            var sideLength = Math.sqrt(Math.pow(box[1][0] - box[0][0], 2) + Math.pow((box[1][1] - box[0][1]), 2)),\n                i,\n                slices = 16,\n                result = null,\n                dir,\n                extension,\n                xdir = Math.sin(lineAngle),\n                ydir = Math.cos(lineAngle);\n\n            for ( i = 1; i < slices && result === null; i++) {\n                // move line perpendicular to angle\n                dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);\n                extension = {\n                    y: dir * xdir,\n                    x: dir * ydir\n                };\n                line[0].y += extension.x;\n                line[0].x -= extension.y;\n                line[1].y += extension.x;\n                line[1].x -= extension.y;\n\n                result = tryDecode(line);\n            }\n            return result;\n        }\n\n        function getLineLength(line) {\n            return Math.sqrt(\n                Math.pow(Math.abs(line[1].y - line[0].y), 2) +\n                Math.pow(Math.abs(line[1].x - line[0].x), 2));\n        }\n\n        /**\n         * With the help of the configured readers (Code128 or EAN) this function tries to detect a\n         * valid barcode pattern within the given area.\n         * @param {Object} box The area to search in\n         * @returns {Object} the result {codeResult, line, angle, pattern, threshold}\n         */\n        function decodeFromBoundingBox(box) {\n            var line,\n                lineAngle,\n                ctx = _canvas.ctx.overlay,\n                result,\n                lineLength;\n\n            if (ENV.development) {\n                if (config.debug.drawBoundingBox && ctx) {\n                    ImageDebug.drawPath(box, {x: 0, y: 1}, ctx, {color: \"blue\", lineWidth: 2});\n                }\n            }\n\n            line = getLine(box);\n            lineLength = getLineLength(line);\n            lineAngle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);\n            line = getExtendedLine(line, lineAngle, Math.floor(lineLength * 0.1));\n            if (line === null){\n                return null;\n            }\n\n            result = tryDecode(line);\n            if (result === null) {\n                result = tryDecodeBruteForce(box, line, lineAngle);\n            }\n\n            if (result === null) {\n                return null;\n            }\n\n            if (ENV.development && result && config.debug.drawScanline && ctx) {\n                ImageDebug.drawPath(line, {x: 'x', y: 'y'}, ctx, {color: 'red', lineWidth: 3});\n            }\n\n            return {\n                codeResult: result.codeResult,\n                line: line,\n                angle: lineAngle,\n                pattern: result.barcodeLine.line,\n                threshold: result.barcodeLine.threshold\n            };\n        }\n\n        return {\n            decodeFromBoundingBox: function(box) {\n                return decodeFromBoundingBox(box);\n            },\n            decodeFromBoundingBoxes: function(boxes) {\n                var i, result,\n                    barcodes = [],\n                    multiple = config.multiple;\n\n                for ( i = 0; i < boxes.length; i++) {\n                    const box = boxes[i];\n                    result = decodeFromBoundingBox(box) || {};\n                    result.box = box;\n\n                    if (multiple) {\n                        barcodes.push(result);\n                    } else if (result.codeResult) {\n                        return result;\n                    }\n                }\n\n                if (multiple) {\n                    return {\n                        barcodes\n                    };\n                }\n            },\n            setReaders: function(readers) {\n                config.readers = readers;\n                _barcodeReaders.length = 0;\n                initReaders();\n            }\n        };\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/decoder/barcode_decoder.js","import ImageWrapper from '../common/image_wrapper';\n\nvar Bresenham = {};\n\nvar Slope = {\n    DIR: {\n        UP: 1,\n        DOWN: -1\n    }\n};\n/**\n * Scans a line of the given image from point p1 to p2 and returns a result object containing\n * gray-scale values (0-255) of the underlying pixels in addition to the min\n * and max values.\n * @param {Object} imageWrapper\n * @param {Object} p1 The start point {x,y}\n * @param {Object} p2 The end point {x,y}\n * @returns {line, min, max}\n */\nBresenham.getBarcodeLine = function(imageWrapper, p1, p2) {\n    var x0 = p1.x | 0,\n        y0 = p1.y | 0,\n        x1 = p2.x | 0,\n        y1 = p2.y | 0,\n        steep = Math.abs(y1 - y0) > Math.abs(x1 - x0),\n        deltax,\n        deltay,\n        error,\n        ystep,\n        y,\n        tmp,\n        x,\n        line = [],\n        imageData = imageWrapper.data,\n        width = imageWrapper.size.x,\n        sum = 0,\n        val,\n        min = 255,\n        max = 0;\n\n    function read(a, b) {\n        val = imageData[b * width + a];\n        sum += val;\n        min = val < min ? val : min;\n        max = val > max ? val : max;\n        line.push(val);\n    }\n\n    if (steep) {\n        tmp = x0;\n        x0 = y0;\n        y0 = tmp;\n\n        tmp = x1;\n        x1 = y1;\n        y1 = tmp;\n    }\n    if (x0 > x1) {\n        tmp = x0;\n        x0 = x1;\n        x1 = tmp;\n\n        tmp = y0;\n        y0 = y1;\n        y1 = tmp;\n    }\n    deltax = x1 - x0;\n    deltay = Math.abs(y1 - y0);\n    error = (deltax / 2) | 0;\n    y = y0;\n    ystep = y0 < y1 ? 1 : -1;\n    for ( x = x0; x < x1; x++) {\n        if (steep){\n            read(y, x);\n        } else {\n            read(x, y);\n        }\n        error = error - deltay;\n        if (error < 0) {\n            y = y + ystep;\n            error = error + deltax;\n        }\n    }\n\n    return {\n        line: line,\n        min: min,\n        max: max\n    };\n};\n\n/**\n * Converts the result from getBarcodeLine into a binary representation\n * also considering the frequency and slope of the signal for more robust results\n * @param {Object} result {line, min, max}\n */\nBresenham.toBinaryLine = function(result) {\n    var min = result.min,\n        max = result.max,\n        line = result.line,\n        slope,\n        slope2,\n        center = min + (max - min) / 2,\n        extrema = [],\n        currentDir,\n        dir,\n        threshold = (max - min) / 12,\n        rThreshold = -threshold,\n        i,\n        j;\n\n    // 1. find extrema\n    currentDir = line[0] > center ? Slope.DIR.UP : Slope.DIR.DOWN;\n    extrema.push({\n        pos: 0,\n        val: line[0]\n    });\n    for ( i = 0; i < line.length - 2; i++) {\n        slope = (line[i + 1] - line[i]);\n        slope2 = (line[i + 2] - line[i + 1]);\n        if ((slope + slope2) < rThreshold && line[i + 1] < (center * 1.5)) {\n            dir = Slope.DIR.DOWN;\n        } else if ((slope + slope2) > threshold && line[i + 1] > (center * 0.5)) {\n            dir = Slope.DIR.UP;\n        } else {\n            dir = currentDir;\n        }\n\n        if (currentDir !== dir) {\n            extrema.push({\n                pos: i,\n                val: line[i]\n            });\n            currentDir = dir;\n        }\n    }\n    extrema.push({\n        pos: line.length,\n        val: line[line.length - 1]\n    });\n\n    for ( j = extrema[0].pos; j < extrema[1].pos; j++) {\n        line[j] = line[j] > center ? 0 : 1;\n    }\n\n    // iterate over extrema and convert to binary based on avg between minmax\n    for ( i = 1; i < extrema.length - 1; i++) {\n        if (extrema[i + 1].val > extrema[i].val) {\n            threshold = (extrema[i].val + ((extrema[i + 1].val - extrema[i].val) / 3) * 2) | 0;\n        } else {\n            threshold = (extrema[i + 1].val + ((extrema[i].val - extrema[i + 1].val) / 3)) | 0;\n        }\n\n        for ( j = extrema[i].pos; j < extrema[i + 1].pos; j++) {\n            line[j] = line[j] > threshold ? 0 : 1;\n        }\n    }\n\n    return {\n        line: line,\n        threshold: threshold\n    };\n};\n\n/**\n * Used for development only\n */\nBresenham.debug = {\n    printFrequency: function(line, canvas) {\n        var i,\n            ctx = canvas.getContext(\"2d\");\n        canvas.width = line.length;\n        canvas.height = 256;\n\n        ctx.beginPath();\n        ctx.strokeStyle = \"blue\";\n        for ( i = 0; i < line.length; i++) {\n            ctx.moveTo(i, 255);\n            ctx.lineTo(i, 255 - line[i]);\n        }\n        ctx.stroke();\n        ctx.closePath();\n    },\n\n    printPattern: function(line, canvas) {\n        var ctx = canvas.getContext(\"2d\"), i;\n\n        canvas.width = line.length;\n        ctx.fillColor = \"black\";\n        for ( i = 0; i < line.length; i++) {\n            if (line[i] === 1) {\n                ctx.fillRect(i, 0, 1, 100);\n            }\n        }\n    }\n};\n\nexport default Bresenham;\n\n\n\n// WEBPACK FOOTER //\n// ./src/decoder/bresenham.js","import {omit, pick} from 'lodash';\nimport {getUserMedia, enumerateDevices} from 'mediaDevices';\n\nconst facingMatching = {\n    \"user\": /front/i,\n    \"environment\": /back/i\n};\n\nvar streamRef;\n\nfunction waitForVideo(video) {\n    return new Promise((resolve, reject) => {\n        let attempts = 10;\n\n        function checkVideo() {\n            if (attempts > 0) {\n                if (video.videoWidth > 0 && video.videoHeight > 0) {\n                    if (ENV.development) {\n                        console.log(video.videoWidth + \"px x \" + video.videoHeight + \"px\");\n                    }\n                    resolve();\n                } else {\n                    window.setTimeout(checkVideo, 500);\n                }\n            } else {\n                reject('Unable to play video stream. Is webcam working?');\n            }\n            attempts--;\n        }\n        checkVideo();\n    });\n}\n\n/**\n * Tries to attach the camera-stream to a given video-element\n * and calls the callback function when the content is ready\n * @param {Object} constraints\n * @param {Object} video\n */\nfunction initCamera(video, constraints) {\n    return getUserMedia(constraints)\n    .then((stream) => {\n        return new Promise((resolve) => {\n            streamRef = stream;\n            video.setAttribute(\"autoplay\", 'true');\n            video.srcObject = stream;\n            video.addEventListener('loadedmetadata', () => {\n                video.play();\n                resolve();\n            });\n        });\n    })\n    .then(waitForVideo.bind(null, video));\n}\n\nfunction deprecatedConstraints(videoConstraints) {\n    const normalized = pick(videoConstraints, [\"width\", \"height\", \"facingMode\",\n            \"aspectRatio\", \"deviceId\"]);\n\n    if (typeof videoConstraints.minAspectRatio !== 'undefined' &&\n            videoConstraints.minAspectRatio > 0) {\n        normalized.aspectRatio = videoConstraints.minAspectRatio;\n        console.log(\"WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead\");\n    }\n    if (typeof videoConstraints.facing !== 'undefined') {\n        normalized.facingMode = videoConstraints.facing;\n        console.log(\"WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'\");\n    }\n    return normalized;\n}\n\nfunction pickDevice(constraints) {\n    const desiredFacing = constraints.video.facingMode,\n        facingMatch = facingMatching[desiredFacing];\n\n    if (!facingMatch) {\n        return Promise.resolve(constraints);\n    }\n    return enumerateDevices()\n    .then(devices => {\n        const selectedDeviceId = devices\n            .filter(device => device.kind === 'videoinput' && facingMatch.test(device.label))\n            .map(facingDevice => facingDevice.deviceId)[0];\n        if (selectedDeviceId) {\n            constraints = {\n                ...constraints,\n                video: {\n                    ...omit(constraints.video, [\"facingMode\"]),\n                    deviceId: selectedDeviceId,\n                }\n            };\n        }\n        return Promise.resolve(constraints);\n    });\n}\n\nexport function pickConstraints(videoConstraints) {\n    const normalizedConstraints = {\n        audio: false,\n        video: deprecatedConstraints(videoConstraints)\n    };\n\n    if (!normalizedConstraints.video.deviceId) {\n        if (typeof normalizedConstraints.video.facingMode === 'string'\n                && normalizedConstraints.video.facingMode.length > 0) {\n            return pickDevice(normalizedConstraints);\n        }\n    }\n    return Promise.resolve(normalizedConstraints);\n}\n\nfunction enumerateVideoDevices() {\n    return enumerateDevices()\n    .then(devices => devices.filter(device => device.kind === 'videoinput'));\n}\n\nexport default {\n    request: function(video, videoConstraints) {\n        return pickConstraints(videoConstraints)\n            .then(initCamera.bind(null, video));\n    },\n    release: function() {\n        var tracks = streamRef && streamRef.getVideoTracks();\n        if (tracks && tracks.length) {\n            tracks[0].stop();\n        }\n        streamRef = null;\n    },\n    enumerateVideoDevices,\n    getActiveStreamLabel: function() {\n        if (streamRef) {\n            const tracks = streamRef.getVideoTracks();\n            if (tracks && tracks.length) {\n                return tracks[0].label;\n            }\n        }\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/input/camera_access.js","import ImageWrapper from '../common/image_wrapper';\nimport {\n    calculatePatchSize,\n    otsuThreshold,\n    hsv2rgb,\n    cluster,\n    topGeneric,\n    imageRef,\n    halfSample,\n    computeImageArea\n} from '../common/cv_utils';\nimport ArrayHelper from '../common/array_helper';\nimport ImageDebug from '../common/image_debug';\nimport Rasterizer from './rasterizer';\nimport Tracer from './tracer';\nimport skeletonizer from './skeletonizer';\nconst vec2 = {\n    clone: require('gl-vec2/clone'),\n    dot:  require('gl-vec2/dot'),\n    scale: require('gl-vec2/scale'),\n    transformMat2: require('gl-vec2/transformMat2')\n};\nconst mat2 = {\n    copy: require('gl-mat2/copy'),\n    create: require('gl-mat2/create'),\n    invert: require('gl-mat2/invert')\n}\n\nvar _config,\n    _currentImageWrapper,\n    _skelImageWrapper,\n    _subImageWrapper,\n    _labelImageWrapper,\n    _patchGrid,\n    _patchLabelGrid,\n    _imageToPatchGrid,\n    _binaryImageWrapper,\n    _patchSize,\n    _canvasContainer = {\n        ctx: {\n            binary: null\n        },\n        dom: {\n            binary: null\n        }\n    },\n    _numPatches = {x: 0, y: 0},\n    _inputImageWrapper,\n    _skeletonizer;\n\nfunction initBuffers() {\n    var skeletonImageData;\n\n    if (_config.halfSample) {\n        _currentImageWrapper = new ImageWrapper({\n            x: _inputImageWrapper.size.x / 2 | 0,\n            y: _inputImageWrapper.size.y / 2 | 0\n        });\n    } else {\n        _currentImageWrapper = _inputImageWrapper;\n    }\n\n    _patchSize = calculatePatchSize(_config.patchSize, _currentImageWrapper.size);\n\n    _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0;\n    _numPatches.y = _currentImageWrapper.size.y / _patchSize.y | 0;\n\n    _binaryImageWrapper = new ImageWrapper(_currentImageWrapper.size, undefined, Uint8Array, false);\n\n    _labelImageWrapper = new ImageWrapper(_patchSize, undefined, Array, true);\n\n    skeletonImageData = new ArrayBuffer(64 * 1024);\n    _subImageWrapper = new ImageWrapper(_patchSize,\n        new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y));\n    _skelImageWrapper = new ImageWrapper(_patchSize,\n        new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y),\n        undefined, true);\n    _skeletonizer = skeletonizer((typeof window !== 'undefined') ? window : (typeof self !== 'undefined') ? self : global, {\n        size: _patchSize.x\n    }, skeletonImageData);\n\n    _imageToPatchGrid = new ImageWrapper({\n        x: (_currentImageWrapper.size.x / _subImageWrapper.size.x) | 0,\n        y: (_currentImageWrapper.size.y / _subImageWrapper.size.y) | 0\n    }, undefined, Array, true);\n    _patchGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, undefined, true);\n    _patchLabelGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, Int32Array, true);\n}\n\nfunction initCanvas() {\n    if (_config.useWorker || typeof document === 'undefined') {\n        return;\n    }\n    _canvasContainer.dom.binary = document.createElement(\"canvas\");\n    _canvasContainer.dom.binary.className = \"binaryBuffer\";\n    if (ENV.development && _config.debug.showCanvas === true) {\n        document.querySelector(\"#debug\").appendChild(_canvasContainer.dom.binary);\n    }\n    _canvasContainer.ctx.binary = _canvasContainer.dom.binary.getContext(\"2d\");\n    _canvasContainer.dom.binary.width = _binaryImageWrapper.size.x;\n    _canvasContainer.dom.binary.height = _binaryImageWrapper.size.y;\n}\n\n/**\n * Creates a bounding box which encloses all the given patches\n * @returns {Array} The minimal bounding box\n */\nfunction boxFromPatches(patches) {\n    var overAvg,\n        i,\n        j,\n        patch,\n        transMat,\n        minx =\n        _binaryImageWrapper.size.x,\n        miny = _binaryImageWrapper.size.y,\n        maxx = -_binaryImageWrapper.size.x,\n        maxy = -_binaryImageWrapper.size.y,\n        box,\n        scale;\n\n    // draw all patches which are to be taken into consideration\n    overAvg = 0;\n    for ( i = 0; i < patches.length; i++) {\n        patch = patches[i];\n        overAvg += patch.rad;\n        if (ENV.development && _config.debug.showPatches) {\n            ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: \"red\"});\n        }\n    }\n\n    overAvg /= patches.length;\n    overAvg = (overAvg * 180 / Math.PI + 90) % 180 - 90;\n    if (overAvg < 0) {\n        overAvg += 180;\n    }\n\n    overAvg = (180 - overAvg) * Math.PI / 180;\n    transMat = mat2.copy(mat2.create(), [Math.cos(overAvg), Math.sin(overAvg), -Math.sin(overAvg), Math.cos(overAvg)]);\n\n    // iterate over patches and rotate by angle\n    for ( i = 0; i < patches.length; i++) {\n        patch = patches[i];\n        for ( j = 0; j < 4; j++) {\n            vec2.transformMat2(patch.box[j], patch.box[j], transMat);\n        }\n\n        if (ENV.development && _config.debug.boxFromPatches.showTransformed) {\n            ImageDebug.drawPath(patch.box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#99ff00', lineWidth: 2});\n        }\n    }\n\n    // find bounding box\n    for ( i = 0; i < patches.length; i++) {\n        patch = patches[i];\n        for ( j = 0; j < 4; j++) {\n            if (patch.box[j][0] < minx) {\n                minx = patch.box[j][0];\n            }\n            if (patch.box[j][0] > maxx) {\n                maxx = patch.box[j][0];\n            }\n            if (patch.box[j][1] < miny) {\n                miny = patch.box[j][1];\n            }\n            if (patch.box[j][1] > maxy) {\n                maxy = patch.box[j][1];\n            }\n        }\n    }\n\n    box = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]];\n\n    if (ENV.development && _config.debug.boxFromPatches.showTransformedBox) {\n        ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2});\n    }\n\n    scale = _config.halfSample ? 2 : 1;\n    // reverse rotation;\n    transMat = mat2.invert(transMat, transMat);\n    for ( j = 0; j < 4; j++) {\n        vec2.transformMat2(box[j], box[j], transMat);\n    }\n\n    if (ENV.development && _config.debug.boxFromPatches.showBB) {\n        ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2});\n    }\n\n    for ( j = 0; j < 4; j++) {\n        vec2.scale(box[j], box[j], scale);\n    }\n\n    return box;\n}\n\n/**\n * Creates a binary image of the current image\n */\nfunction binarizeImage() {\n    otsuThreshold(_currentImageWrapper, _binaryImageWrapper);\n    _binaryImageWrapper.zeroBorder();\n    if (ENV.development && _config.debug.showCanvas) {\n        _binaryImageWrapper.show(_canvasContainer.dom.binary, 255);\n    }\n}\n\n/**\n * Iterate over the entire image\n * extract patches\n */\nfunction findPatches() {\n    var i,\n        j,\n        x,\n        y,\n        moments,\n        patchesFound = [],\n        rasterizer,\n        rasterResult,\n        patch;\n    for (i = 0; i < _numPatches.x; i++) {\n        for (j = 0; j < _numPatches.y; j++) {\n            x = _subImageWrapper.size.x * i;\n            y = _subImageWrapper.size.y * j;\n\n            // seperate parts\n            skeletonize(x, y);\n\n            // Rasterize, find individual bars\n            _skelImageWrapper.zeroBorder();\n            ArrayHelper.init(_labelImageWrapper.data, 0);\n            rasterizer = Rasterizer.create(_skelImageWrapper, _labelImageWrapper);\n            rasterResult = rasterizer.rasterize(0);\n\n            if (ENV.development && _config.debug.showLabels) {\n                _labelImageWrapper.overlay(_canvasContainer.dom.binary, Math.floor(360 / rasterResult.count),\n                    {x: x, y: y});\n            }\n\n            // calculate moments from the skeletonized patch\n            moments = _labelImageWrapper.moments(rasterResult.count);\n\n            // extract eligible patches\n            patchesFound = patchesFound.concat(describePatch(moments, [i, j], x, y));\n        }\n    }\n\n    if (ENV.development && _config.debug.showFoundPatches) {\n        for ( i = 0; i < patchesFound.length; i++) {\n            patch = patchesFound[i];\n            ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary,\n                {color: \"#99ff00\", lineWidth: 2});\n        }\n    }\n\n    return patchesFound;\n}\n\n/**\n * Finds those connected areas which contain at least 6 patches\n * and returns them ordered DESC by the number of contained patches\n * @param {Number} maxLabel\n */\nfunction findBiggestConnectedAreas(maxLabel){\n    var i,\n        sum,\n        labelHist = [],\n        topLabels = [];\n\n    for ( i = 0; i < maxLabel; i++) {\n        labelHist.push(0);\n    }\n    sum = _patchLabelGrid.data.length;\n    while (sum--) {\n        if (_patchLabelGrid.data[sum] > 0) {\n            labelHist[_patchLabelGrid.data[sum] - 1]++;\n        }\n    }\n\n    labelHist = labelHist.map(function(val, idx) {\n        return {\n            val: val,\n            label: idx + 1\n        };\n    });\n\n    labelHist.sort(function(a, b) {\n        return b.val - a.val;\n    });\n\n    // extract top areas with at least 6 patches present\n    topLabels = labelHist.filter(function(el) {\n        return el.val >= 5;\n    });\n\n    return topLabels;\n}\n\n/**\n *\n */\nfunction findBoxes(topLabels, maxLabel) {\n    var i,\n        j,\n        sum,\n        patches = [],\n        patch,\n        box,\n        boxes = [],\n        hsv = [0, 1, 1],\n        rgb = [0, 0, 0];\n\n    for ( i = 0; i < topLabels.length; i++) {\n        sum = _patchLabelGrid.data.length;\n        patches.length = 0;\n        while (sum--) {\n            if (_patchLabelGrid.data[sum] === topLabels[i].label) {\n                patch = _imageToPatchGrid.data[sum];\n                patches.push(patch);\n            }\n        }\n        box = boxFromPatches(patches);\n        if (box) {\n            boxes.push(box);\n\n            // draw patch-labels if requested\n            if (ENV.development && _config.debug.showRemainingPatchLabels) {\n                for ( j = 0; j < patches.length; j++) {\n                    patch = patches[j];\n                    hsv[0] = (topLabels[i].label / (maxLabel + 1)) * 360;\n                    hsv2rgb(hsv, rgb);\n                    ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary,\n                        {color: \"rgb(\" + rgb.join(\",\") + \")\", lineWidth: 2});\n                }\n            }\n        }\n    }\n    return boxes;\n}\n\n/**\n * Find similar moments (via cluster)\n * @param {Object} moments\n */\nfunction similarMoments(moments) {\n    var clusters = cluster(moments, 0.90);\n    var topCluster = topGeneric(clusters, 1, function(e) {\n        return e.getPoints().length;\n    });\n    var points = [], result = [];\n    if (topCluster.length === 1) {\n        points = topCluster[0].item.getPoints();\n        for (var i = 0; i < points.length; i++) {\n            result.push(points[i].point);\n        }\n    }\n    return result;\n}\n\nfunction skeletonize(x, y) {\n    _binaryImageWrapper.subImageAsCopy(_subImageWrapper, imageRef(x, y));\n    _skeletonizer.skeletonize();\n\n    // Show skeleton if requested\n    if (ENV.development && _config.debug.showSkeleton) {\n        _skelImageWrapper.overlay(_canvasContainer.dom.binary, 360, imageRef(x, y));\n    }\n}\n\n/**\n * Extracts and describes those patches which seem to contain a barcode pattern\n * @param {Array} moments\n * @param {Object} patchPos,\n * @param {Number} x\n * @param {Number} y\n * @returns {Array} list of patches\n */\nfunction describePatch(moments, patchPos, x, y) {\n    var k,\n        avg,\n        eligibleMoments = [],\n        matchingMoments,\n        patch,\n        patchesFound = [],\n        minComponentWeight = Math.ceil(_patchSize.x / 3);\n\n    if (moments.length >= 2) {\n        // only collect moments which's area covers at least minComponentWeight pixels.\n        for ( k = 0; k < moments.length; k++) {\n            if (moments[k].m00 > minComponentWeight) {\n                eligibleMoments.push(moments[k]);\n            }\n        }\n\n        // if at least 2 moments are found which have at least minComponentWeights covered\n        if (eligibleMoments.length >= 2) {\n            matchingMoments = similarMoments(eligibleMoments);\n            avg = 0;\n            // determine the similarity of the moments\n            for ( k = 0; k < matchingMoments.length; k++) {\n                avg += matchingMoments[k].rad;\n            }\n\n            // Only two of the moments are allowed not to fit into the equation\n            // add the patch to the set\n            if (matchingMoments.length > 1\n                    && matchingMoments.length >= (eligibleMoments.length / 4) * 3\n                    && matchingMoments.length > moments.length / 4) {\n                avg /= matchingMoments.length;\n                patch = {\n                    index: patchPos[1] * _numPatches.x + patchPos[0],\n                    pos: {\n                        x: x,\n                        y: y\n                    },\n                    box: [\n                        vec2.clone([x, y]),\n                        vec2.clone([x + _subImageWrapper.size.x, y]),\n                        vec2.clone([x + _subImageWrapper.size.x, y + _subImageWrapper.size.y]),\n                        vec2.clone([x, y + _subImageWrapper.size.y])\n                    ],\n                    moments: matchingMoments,\n                    rad: avg,\n                    vec: vec2.clone([Math.cos(avg), Math.sin(avg)])\n                };\n                patchesFound.push(patch);\n            }\n        }\n    }\n    return patchesFound;\n}\n\n/**\n * finds patches which are connected and share the same orientation\n * @param {Object} patchesFound\n */\nfunction rasterizeAngularSimilarity(patchesFound) {\n    var label = 0,\n        threshold = 0.95,\n        currIdx = 0,\n        j,\n        patch,\n        hsv = [0, 1, 1],\n        rgb = [0, 0, 0];\n\n    function notYetProcessed() {\n        var i;\n        for ( i = 0; i < _patchLabelGrid.data.length; i++) {\n            if (_patchLabelGrid.data[i] === 0 && _patchGrid.data[i] === 1) {\n                return i;\n            }\n        }\n        return _patchLabelGrid.length;\n    }\n\n    function trace(currentIdx) {\n        var x,\n            y,\n            currentPatch,\n            idx,\n            dir,\n            current = {\n                x: currentIdx % _patchLabelGrid.size.x,\n                y: (currentIdx / _patchLabelGrid.size.x) | 0\n            },\n            similarity;\n\n        if (currentIdx < _patchLabelGrid.data.length) {\n            currentPatch = _imageToPatchGrid.data[currentIdx];\n            // assign label\n            _patchLabelGrid.data[currentIdx] = label;\n            for ( dir = 0; dir < Tracer.searchDirections.length; dir++) {\n                y = current.y + Tracer.searchDirections[dir][0];\n                x = current.x + Tracer.searchDirections[dir][1];\n                idx = y * _patchLabelGrid.size.x + x;\n\n                // continue if patch empty\n                if (_patchGrid.data[idx] === 0) {\n                    _patchLabelGrid.data[idx] = Number.MAX_VALUE;\n                    continue;\n                }\n\n                if (_patchLabelGrid.data[idx] === 0) {\n                    similarity = Math.abs(vec2.dot(_imageToPatchGrid.data[idx].vec, currentPatch.vec));\n                    if (similarity > threshold) {\n                        trace(idx);\n                    }\n                }\n            }\n        }\n    }\n\n    // prepare for finding the right patches\n    ArrayHelper.init(_patchGrid.data, 0);\n    ArrayHelper.init(_patchLabelGrid.data, 0);\n    ArrayHelper.init(_imageToPatchGrid.data, null);\n\n    for ( j = 0; j < patchesFound.length; j++) {\n        patch = patchesFound[j];\n        _imageToPatchGrid.data[patch.index] = patch;\n        _patchGrid.data[patch.index] = 1;\n    }\n\n    // rasterize the patches found to determine area\n    _patchGrid.zeroBorder();\n\n    while (( currIdx = notYetProcessed()) < _patchLabelGrid.data.length) {\n        label++;\n        trace(currIdx);\n    }\n\n    // draw patch-labels if requested\n    if (ENV.development && _config.debug.showPatchLabels) {\n        for ( j = 0; j < _patchLabelGrid.data.length; j++) {\n            if (_patchLabelGrid.data[j] > 0 && _patchLabelGrid.data[j] <= label) {\n                patch = _imageToPatchGrid.data[j];\n                hsv[0] = (_patchLabelGrid.data[j] / (label + 1)) * 360;\n                hsv2rgb(hsv, rgb);\n                ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary,\n                    {color: \"rgb(\" + rgb.join(\",\") + \")\", lineWidth: 2});\n            }\n        }\n    }\n\n    return label;\n}\n\nexport default {\n    init: function(inputImageWrapper, config) {\n        _config = config;\n        _inputImageWrapper = inputImageWrapper;\n\n        initBuffers();\n        initCanvas();\n    },\n\n    locate: function() {\n        var patchesFound,\n            topLabels,\n            boxes;\n\n        if (_config.halfSample) {\n            halfSample(_inputImageWrapper, _currentImageWrapper);\n        }\n\n        binarizeImage();\n        patchesFound = findPatches();\n        // return unless 5% or more patches are found\n        if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) {\n            return null;\n        }\n\n        // rasterrize area by comparing angular similarity;\n        var maxLabel = rasterizeAngularSimilarity(patchesFound);\n        if (maxLabel < 1) {\n            return null;\n        }\n\n        // search for area with the most patches (biggest connected area)\n        topLabels = findBiggestConnectedAreas(maxLabel);\n        if (topLabels.length === 0) {\n            return null;\n        }\n\n        boxes = findBoxes(topLabels, maxLabel);\n        return boxes;\n    },\n\n    checkImageConstraints: function(inputStream, config) {\n        var patchSize,\n            width = inputStream.getWidth(),\n            height = inputStream.getHeight(),\n            halfSample = config.halfSample ? 0.5 : 1,\n            size,\n            area;\n\n        // calculate width and height based on area\n        if (inputStream.getConfig().area) {\n            area = computeImageArea(width, height, inputStream.getConfig().area);\n            inputStream.setTopRight({x: area.sx, y: area.sy});\n            inputStream.setCanvasSize({x: width, y: height});\n            width = area.sw;\n            height = area.sh;\n        }\n\n        size = {\n            x: Math.floor(width * halfSample),\n            y: Math.floor(height * halfSample)\n        };\n\n        patchSize = calculatePatchSize(config.patchSize, size);\n        if (ENV.development) {\n            console.log(\"Patch-Size: \" + JSON.stringify(patchSize));\n        }\n\n        inputStream.setWidth(Math.floor(Math.floor(size.x / patchSize.x) * (1 / halfSample) * patchSize.x));\n        inputStream.setHeight(Math.floor(Math.floor(size.y / patchSize.y) * (1 / halfSample) * patchSize.y));\n\n        if ((inputStream.getWidth() % patchSize.x) === 0 && (inputStream.getHeight() % patchSize.y) === 0) {\n            return true;\n        }\n\n        throw new Error(\"Image dimensions do not comply with the current settings: Width (\" +\n            width + \" )and height (\" + height +\n            \") must a multiple of \" + patchSize.x);\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/barcode_locator.js","import Tracer from './tracer';\n\n/**\n * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\nvar Rasterizer = {\n    createContour2D: function() {\n        return {\n            dir: null,\n            index: null,\n            firstVertex: null,\n            insideContours: null,\n            nextpeer: null,\n            prevpeer: null\n        };\n    },\n    CONTOUR_DIR: {\n        CW_DIR: 0,\n        CCW_DIR: 1,\n        UNKNOWN_DIR: 2\n    },\n    DIR: {\n        OUTSIDE_EDGE: -32767,\n        INSIDE_EDGE: -32766\n    },\n    create: function(imageWrapper, labelWrapper) {\n        var imageData = imageWrapper.data,\n            labelData = labelWrapper.data,\n            width = imageWrapper.size.x,\n            height = imageWrapper.size.y,\n            tracer = Tracer.create(imageWrapper, labelWrapper);\n\n        return {\n            rasterize: function(depthlabel) {\n                var color,\n                    bc,\n                    lc,\n                    labelindex,\n                    cx,\n                    cy,\n                    colorMap = [],\n                    vertex,\n                    p,\n                    cc,\n                    sc,\n                    pos,\n                    connectedCount = 0,\n                    i;\n\n                for ( i = 0; i < 400; i++) {\n                    colorMap[i] = 0;\n                }\n\n                colorMap[0] = imageData[0];\n                cc = null;\n                for ( cy = 1; cy < height - 1; cy++) {\n                    labelindex = 0;\n                    bc = colorMap[0];\n                    for ( cx = 1; cx < width - 1; cx++) {\n                        pos = cy * width + cx;\n                        if (labelData[pos] === 0) {\n                            color = imageData[pos];\n                            if (color !== bc) {\n                                if (labelindex === 0) {\n                                    lc = connectedCount + 1;\n                                    colorMap[lc] = color;\n                                    bc = color;\n                                    vertex = tracer.contourTracing(cy, cx, lc, color, Rasterizer.DIR.OUTSIDE_EDGE);\n                                    if (vertex !== null) {\n                                        connectedCount++;\n                                        labelindex = lc;\n                                        p = Rasterizer.createContour2D();\n                                        p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;\n                                        p.index = labelindex;\n                                        p.firstVertex = vertex;\n                                        p.nextpeer = cc;\n                                        p.insideContours = null;\n                                        if (cc !== null) {\n                                            cc.prevpeer = p;\n                                        }\n                                        cc = p;\n                                    }\n                                } else {\n                                    vertex = tracer\n                                        .contourTracing(cy, cx, Rasterizer.DIR.INSIDE_EDGE, color, labelindex);\n                                    if (vertex !== null) {\n                                        p = Rasterizer.createContour2D();\n                                        p.firstVertex = vertex;\n                                        p.insideContours = null;\n                                        if (depthlabel === 0) {\n                                            p.dir = Rasterizer.CONTOUR_DIR.CCW_DIR;\n                                        } else {\n                                            p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;\n                                        }\n                                        p.index = depthlabel;\n                                        sc = cc;\n                                        while ((sc !== null) && sc.index !== labelindex) {\n                                            sc = sc.nextpeer;\n                                        }\n                                        if (sc !== null) {\n                                            p.nextpeer = sc.insideContours;\n                                            if (sc.insideContours !== null) {\n                                                sc.insideContours.prevpeer = p;\n                                            }\n                                            sc.insideContours = p;\n                                        }\n                                    }\n                                }\n                            } else {\n                                labelData[pos] = labelindex;\n                            }\n                        } else if (labelData[pos] === Rasterizer.DIR.OUTSIDE_EDGE\n                                || labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {\n                            labelindex = 0;\n                            if (labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {\n                                bc = imageData[pos];\n                            } else {\n                                bc = colorMap[0];\n                            }\n                        } else {\n                            labelindex = labelData[pos];\n                            bc = colorMap[labelindex];\n                        }\n                    }\n                }\n                sc = cc;\n                while (sc !== null) {\n                    sc.index = depthlabel;\n                    sc = sc.nextpeer;\n                }\n                return {\n                    cc: cc,\n                    count: connectedCount\n                };\n            },\n            debug: {\n                drawContour: function(canvas, firstContour) {\n                    var ctx = canvas.getContext(\"2d\"),\n                        pq = firstContour,\n                        iq,\n                        q,\n                        p;\n\n                    ctx.strokeStyle = \"red\";\n                    ctx.fillStyle = \"red\";\n                    ctx.lineWidth = 1;\n\n                    if (pq !== null) {\n                        iq = pq.insideContours;\n                    } else {\n                        iq = null;\n                    }\n\n                    while (pq !== null) {\n                        if (iq !== null) {\n                            q = iq;\n                            iq = iq.nextpeer;\n                        } else {\n                            q = pq;\n                            pq = pq.nextpeer;\n                            if (pq !== null) {\n                                iq = pq.insideContours;\n                            } else {\n                                iq = null;\n                            }\n                        }\n\n                        switch (q.dir) {\n                        case Rasterizer.CONTOUR_DIR.CW_DIR:\n                            ctx.strokeStyle = \"red\";\n                            break;\n                        case Rasterizer.CONTOUR_DIR.CCW_DIR:\n                            ctx.strokeStyle = \"blue\";\n                            break;\n                        case Rasterizer.CONTOUR_DIR.UNKNOWN_DIR:\n                            ctx.strokeStyle = \"green\";\n                            break;\n                        }\n\n                        p = q.firstVertex;\n                        ctx.beginPath();\n                        ctx.moveTo(p.x, p.y);\n                        do {\n                            p = p.next;\n                            ctx.lineTo(p.x, p.y);\n                        } while (p !== q.firstVertex);\n                        ctx.stroke();\n                    }\n                }\n            }\n        };\n    }\n};\n\nexport default Rasterizer;\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/rasterizer.js","/* @preserve ASM BEGIN */\n/* eslint-disable eqeqeq*/\nfunction Skeletonizer(stdlib, foreign, buffer) {\n    \"use asm\";\n\n    var images = new stdlib.Uint8Array(buffer),\n        size = foreign.size | 0,\n        imul = stdlib.Math.imul;\n\n    function erode(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) == (5 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function subtract(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) - (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) | (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function countNonZero(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var sum = 0,\n            length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            sum = ((sum | 0) + (images[(imagePtr + length) | 0] | 0)) | 0;\n        }\n\n        return (sum | 0);\n    }\n\n    function init(imagePtr, value) {\n        imagePtr = imagePtr | 0;\n        value = value | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(imagePtr + length) | 0] = value;\n        }\n    }\n\n    function dilate(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) > (0 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function memcpy(srcImagePtr, dstImagePtr) {\n        srcImagePtr = srcImagePtr | 0;\n        dstImagePtr = dstImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(dstImagePtr + length) | 0] = (images[(srcImagePtr + length) | 0] | 0);\n        }\n    }\n\n    function zeroBorder(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var x = 0,\n            y = 0;\n\n        for ( x = 0; (x | 0) < ((size - 1) | 0); x = (x + 1) | 0) {\n            images[(imagePtr + x) | 0] = 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = ((y + size) - 1) | 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n        for ( x = 0; (x | 0) < (size | 0); x = (x + 1) | 0) {\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n    }\n\n    function skeletonize() {\n        var subImagePtr = 0,\n            erodedImagePtr = 0,\n            tempImagePtr = 0,\n            skelImagePtr = 0,\n            sum = 0,\n            done = 0;\n\n        erodedImagePtr = imul(size, size) | 0;\n        tempImagePtr = (erodedImagePtr + erodedImagePtr) | 0;\n        skelImagePtr = (tempImagePtr + erodedImagePtr) | 0;\n\n        // init skel-image\n        init(skelImagePtr, 0);\n        zeroBorder(subImagePtr);\n\n        do {\n            erode(subImagePtr, erodedImagePtr);\n            dilate(erodedImagePtr, tempImagePtr);\n            subtract(subImagePtr, tempImagePtr, tempImagePtr);\n            bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);\n            memcpy(erodedImagePtr, subImagePtr);\n            sum = countNonZero(subImagePtr) | 0;\n            done = ((sum | 0) == 0 | 0);\n        } while (!done);\n    }\n    return {\n        skeletonize: skeletonize\n    };\n}\n/* @preserve ASM END */\nexport default Skeletonizer;\n/* eslint-enable eqeqeq*/\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/skeletonizer.js","import BarcodeReader from './barcode_reader';\n\nfunction CodabarReader() {\n    BarcodeReader.call(this);\n    this._counters = [];\n}\n\nvar properties = {\n    ALPHABETH_STRING: {value: \"0123456789-$:/.+ABCD\"},\n    ALPHABET: {value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68]},\n    CHARACTER_ENCODINGS: {value: [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018,\n        0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E]},\n    START_END: {value: [0x01A, 0x029, 0x00B, 0x00E]},\n    MIN_ENCODED_CHARS: {value: 4},\n    MAX_ACCEPTABLE: {value: 2.0},\n    PADDING: {value: 1.5},\n    FORMAT: {value: \"codabar\", writeable: false}\n};\n\nCodabarReader.prototype = Object.create(BarcodeReader.prototype, properties);\nCodabarReader.prototype.constructor = CodabarReader;\n\nCodabarReader.prototype._decode = function() {\n    var self = this,\n        result = [],\n        start,\n        decodedChar,\n        pattern,\n        nextStart,\n        end;\n\n    this._counters = self._fillCounters();\n    start = self._findStart();\n    if (!start) {\n        return null;\n    }\n    nextStart = start.startCounter;\n\n    do {\n        pattern = self._toPattern(nextStart);\n        if (pattern < 0) {\n            return null;\n        }\n        decodedChar = self._patternToChar(pattern);\n        if (decodedChar < 0){\n            return null;\n        }\n        result.push(decodedChar);\n        nextStart += 8;\n        if (result.length > 1 && self._isStartEnd(pattern)) {\n            break;\n        }\n    } while (nextStart < self._counters.length);\n\n    // verify end\n    if ((result.length - 2) < self.MIN_ENCODED_CHARS || !self._isStartEnd(pattern)) {\n        return null;\n    }\n\n    // verify end white space\n    if (!self._verifyWhitespace(start.startCounter, nextStart - 8)){\n        return null;\n    }\n\n    if (!self._validateResult(result, start.startCounter)){\n        return null;\n    }\n\n    nextStart = nextStart > self._counters.length ? self._counters.length : nextStart;\n    end = start.start + self._sumCounters(start.startCounter, nextStart - 8);\n\n    return {\n        code: result.join(\"\"),\n        start: start.start,\n        end: end,\n        startInfo: start,\n        decodedCodes: result\n    };\n};\n\nCodabarReader.prototype._verifyWhitespace = function(startCounter, endCounter) {\n    if ((startCounter - 1 <= 0)\n            || this._counters[startCounter - 1] >= (this._calculatePatternLength(startCounter) / 2.0)) {\n        if ((endCounter + 8 >= this._counters.length)\n                || this._counters[endCounter + 7] >= (this._calculatePatternLength(endCounter) / 2.0)) {\n            return true;\n        }\n    }\n    return false;\n};\n\nCodabarReader.prototype._calculatePatternLength = function(offset) {\n    var i,\n        sum = 0;\n\n    for (i = offset; i < offset + 7; i++) {\n        sum += this._counters[i];\n    }\n\n    return sum;\n};\n\nCodabarReader.prototype._thresholdResultPattern = function(result, startCounter){\n    var self = this,\n        categorization = {\n            space: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE},\n                wide: {size: 0, counts: 0, min: 0, max: Number.MAX_VALUE}\n            },\n            bar: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE},\n                wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE}\n            }\n        },\n        kind,\n        cat,\n        i,\n        j,\n        pos = startCounter,\n        pattern;\n\n    for (i = 0; i < result.length; i++){\n        pattern = self._charToPattern(result[i]);\n        for (j = 6; j >= 0; j--) {\n            kind = (j & 1) === 2 ? categorization.bar : categorization.space;\n            cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n            cat.size += self._counters[pos + j];\n            cat.counts++;\n            pattern >>= 1;\n        }\n        pos += 8;\n    }\n\n    [\"space\", \"bar\"].forEach(function(key) {\n        var newkind = categorization[key];\n        newkind.wide.min =\n            Math.floor((newkind.narrow.size / newkind.narrow.counts + newkind.wide.size / newkind.wide.counts) / 2);\n        newkind.narrow.max = Math.ceil(newkind.wide.min);\n        newkind.wide.max = Math.ceil((newkind.wide.size * self.MAX_ACCEPTABLE + self.PADDING) / newkind.wide.counts);\n    });\n\n    return categorization;\n};\n\nCodabarReader.prototype._charToPattern = function(char) {\n    var self = this,\n        charCode = char.charCodeAt(0),\n        i;\n\n    for (i = 0; i < self.ALPHABET.length; i++) {\n        if (self.ALPHABET[i] === charCode){\n            return self.CHARACTER_ENCODINGS[i];\n        }\n    }\n    return 0x0;\n};\n\nCodabarReader.prototype._validateResult = function(result, startCounter) {\n    var self = this,\n        thresholds = self._thresholdResultPattern(result, startCounter),\n        i,\n        j,\n        kind,\n        cat,\n        size,\n        pos = startCounter,\n        pattern;\n\n    for (i = 0; i < result.length; i++) {\n        pattern = self._charToPattern(result[i]);\n        for (j = 6; j >= 0; j--) {\n            kind = (j & 1) === 0 ? thresholds.bar : thresholds.space;\n            cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n            size = self._counters[pos + j];\n            if (size < cat.min || size > cat.max) {\n                return false;\n            }\n            pattern >>= 1;\n        }\n        pos += 8;\n    }\n    return true;\n};\n\nCodabarReader.prototype._patternToChar = function(pattern) {\n    var i,\n        self = this;\n\n    for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {\n        if (self.CHARACTER_ENCODINGS[i] === pattern) {\n            return String.fromCharCode(self.ALPHABET[i]);\n        }\n    }\n    return -1;\n};\n\nCodabarReader.prototype._computeAlternatingThreshold = function(offset, end) {\n    var i,\n        min = Number.MAX_VALUE,\n        max = 0,\n        counter;\n\n    for (i = offset; i < end; i += 2){\n        counter = this._counters[i];\n        if (counter > max) {\n            max = counter;\n        }\n        if (counter < min) {\n            min = counter;\n        }\n    }\n\n    return ((min + max) / 2.0) | 0;\n};\n\nCodabarReader.prototype._toPattern = function(offset) {\n    var numCounters = 7,\n        end = offset + numCounters,\n        barThreshold,\n        spaceThreshold,\n        bitmask = 1 << (numCounters - 1),\n        pattern = 0,\n        i,\n        threshold;\n\n    if (end > this._counters.length) {\n        return -1;\n    }\n\n    barThreshold = this._computeAlternatingThreshold(offset, end);\n    spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);\n\n    for (i = 0; i < numCounters; i++){\n        threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;\n        if (this._counters[offset + i] > threshold) {\n            pattern |= bitmask;\n        }\n        bitmask >>= 1;\n    }\n\n    return pattern;\n};\n\nCodabarReader.prototype._isStartEnd = function(pattern) {\n    var i;\n\n    for (i = 0; i < this.START_END.length; i++) {\n        if (this.START_END[i] === pattern) {\n            return true;\n        }\n    }\n    return false;\n};\n\nCodabarReader.prototype._sumCounters = function(start, end) {\n    var i,\n        sum = 0;\n\n    for (i = start; i < end; i++) {\n        sum += this._counters[i];\n    }\n    return sum;\n};\n\nCodabarReader.prototype._findStart = function() {\n    var self = this,\n        i,\n        pattern,\n        start = self._nextUnset(self._row),\n        end;\n\n    for (i = 1; i < this._counters.length; i++) {\n        pattern = self._toPattern(i);\n        if (pattern !== -1 && self._isStartEnd(pattern)) {\n            // TODO: Look for whitespace ahead\n            start += self._sumCounters(0, i);\n            end = start + self._sumCounters(i, i + 8);\n            return {\n                start: start,\n                end: end,\n                startCounter: i,\n                endCounter: i + 8\n            };\n        }\n    }\n};\n\nexport default CodabarReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/codabar_reader.js","import BarcodeReader from './barcode_reader';\n\nfunction Code128Reader() {\n    BarcodeReader.call(this);\n}\n\nvar properties = {\n    CODE_SHIFT: {value: 98},\n    CODE_C: {value: 99},\n    CODE_B: {value: 100},\n    CODE_A: {value: 101},\n    START_CODE_A: {value: 103},\n    START_CODE_B: {value: 104},\n    START_CODE_C: {value: 105},\n    STOP_CODE: {value: 106},\n    CODE_PATTERN: {value: [\n        [2, 1, 2, 2, 2, 2],\n        [2, 2, 2, 1, 2, 2],\n        [2, 2, 2, 2, 2, 1],\n        [1, 2, 1, 2, 2, 3],\n        [1, 2, 1, 3, 2, 2],\n        [1, 3, 1, 2, 2, 2],\n        [1, 2, 2, 2, 1, 3],\n        [1, 2, 2, 3, 1, 2],\n        [1, 3, 2, 2, 1, 2],\n        [2, 2, 1, 2, 1, 3],\n        [2, 2, 1, 3, 1, 2],\n        [2, 3, 1, 2, 1, 2],\n        [1, 1, 2, 2, 3, 2],\n        [1, 2, 2, 1, 3, 2],\n        [1, 2, 2, 2, 3, 1],\n        [1, 1, 3, 2, 2, 2],\n        [1, 2, 3, 1, 2, 2],\n        [1, 2, 3, 2, 2, 1],\n        [2, 2, 3, 2, 1, 1],\n        [2, 2, 1, 1, 3, 2],\n        [2, 2, 1, 2, 3, 1],\n        [2, 1, 3, 2, 1, 2],\n        [2, 2, 3, 1, 1, 2],\n        [3, 1, 2, 1, 3, 1],\n        [3, 1, 1, 2, 2, 2],\n        [3, 2, 1, 1, 2, 2],\n        [3, 2, 1, 2, 2, 1],\n        [3, 1, 2, 2, 1, 2],\n        [3, 2, 2, 1, 1, 2],\n        [3, 2, 2, 2, 1, 1],\n        [2, 1, 2, 1, 2, 3],\n        [2, 1, 2, 3, 2, 1],\n        [2, 3, 2, 1, 2, 1],\n        [1, 1, 1, 3, 2, 3],\n        [1, 3, 1, 1, 2, 3],\n        [1, 3, 1, 3, 2, 1],\n        [1, 1, 2, 3, 1, 3],\n        [1, 3, 2, 1, 1, 3],\n        [1, 3, 2, 3, 1, 1],\n        [2, 1, 1, 3, 1, 3],\n        [2, 3, 1, 1, 1, 3],\n        [2, 3, 1, 3, 1, 1],\n        [1, 1, 2, 1, 3, 3],\n        [1, 1, 2, 3, 3, 1],\n        [1, 3, 2, 1, 3, 1],\n        [1, 1, 3, 1, 2, 3],\n        [1, 1, 3, 3, 2, 1],\n        [1, 3, 3, 1, 2, 1],\n        [3, 1, 3, 1, 2, 1],\n        [2, 1, 1, 3, 3, 1],\n        [2, 3, 1, 1, 3, 1],\n        [2, 1, 3, 1, 1, 3],\n        [2, 1, 3, 3, 1, 1],\n        [2, 1, 3, 1, 3, 1],\n        [3, 1, 1, 1, 2, 3],\n        [3, 1, 1, 3, 2, 1],\n        [3, 3, 1, 1, 2, 1],\n        [3, 1, 2, 1, 1, 3],\n        [3, 1, 2, 3, 1, 1],\n        [3, 3, 2, 1, 1, 1],\n        [3, 1, 4, 1, 1, 1],\n        [2, 2, 1, 4, 1, 1],\n        [4, 3, 1, 1, 1, 1],\n        [1, 1, 1, 2, 2, 4],\n        [1, 1, 1, 4, 2, 2],\n        [1, 2, 1, 1, 2, 4],\n        [1, 2, 1, 4, 2, 1],\n        [1, 4, 1, 1, 2, 2],\n        [1, 4, 1, 2, 2, 1],\n        [1, 1, 2, 2, 1, 4],\n        [1, 1, 2, 4, 1, 2],\n        [1, 2, 2, 1, 1, 4],\n        [1, 2, 2, 4, 1, 1],\n        [1, 4, 2, 1, 1, 2],\n        [1, 4, 2, 2, 1, 1],\n        [2, 4, 1, 2, 1, 1],\n        [2, 2, 1, 1, 1, 4],\n        [4, 1, 3, 1, 1, 1],\n        [2, 4, 1, 1, 1, 2],\n        [1, 3, 4, 1, 1, 1],\n        [1, 1, 1, 2, 4, 2],\n        [1, 2, 1, 1, 4, 2],\n        [1, 2, 1, 2, 4, 1],\n        [1, 1, 4, 2, 1, 2],\n        [1, 2, 4, 1, 1, 2],\n        [1, 2, 4, 2, 1, 1],\n        [4, 1, 1, 2, 1, 2],\n        [4, 2, 1, 1, 1, 2],\n        [4, 2, 1, 2, 1, 1],\n        [2, 1, 2, 1, 4, 1],\n        [2, 1, 4, 1, 2, 1],\n        [4, 1, 2, 1, 2, 1],\n        [1, 1, 1, 1, 4, 3],\n        [1, 1, 1, 3, 4, 1],\n        [1, 3, 1, 1, 4, 1],\n        [1, 1, 4, 1, 1, 3],\n        [1, 1, 4, 3, 1, 1],\n        [4, 1, 1, 1, 1, 3],\n        [4, 1, 1, 3, 1, 1],\n        [1, 1, 3, 1, 4, 1],\n        [1, 1, 4, 1, 3, 1],\n        [3, 1, 1, 1, 4, 1],\n        [4, 1, 1, 1, 3, 1],\n        [2, 1, 1, 4, 1, 2],\n        [2, 1, 1, 2, 1, 4],\n        [2, 1, 1, 2, 3, 2],\n        [2, 3, 3, 1, 1, 1, 2]\n    ]},\n    SINGLE_CODE_ERROR: {value: 0.64},\n    AVG_CODE_ERROR: {value: 0.30},\n    FORMAT: {value: \"code_128\", writeable: false},\n    MODULE_INDICES: {value: {bar: [0, 2, 4], space: [1, 3, 5]}}\n};\n\nCode128Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nCode128Reader.prototype.constructor = Code128Reader;\n\nCode128Reader.prototype._decodeCode = function(start, correction) {\n    var counter = [0, 0, 0, 0, 0, 0],\n        i,\n        self = this,\n        offset = start,\n        isWhite = !self._row[offset],\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        },\n        code,\n        error;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                if (correction) {\n                    self._correct(counter, correction);\n                }\n                for (code = 0; code < self.CODE_PATTERN.length; code++) {\n                    error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n                    if (error < bestMatch.error) {\n                        bestMatch.code = code;\n                        bestMatch.error = error;\n                    }\n                }\n                bestMatch.end = i;\n                if (bestMatch.code === -1 || bestMatch.error > self.AVG_CODE_ERROR) {\n                    return null;\n                }\n                if (self.CODE_PATTERN[bestMatch.code]) {\n                    bestMatch.correction.bar = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.bar);\n                    bestMatch.correction.space = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.space);\n                }\n                return bestMatch;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nCode128Reader.prototype._correct = function(counter, correction) {\n    this._correctBars(counter, correction.bar, this.MODULE_INDICES.bar);\n    this._correctBars(counter, correction.space, this.MODULE_INDICES.space);\n};\n\nCode128Reader.prototype._findStart = function() {\n    var counter = [0, 0, 0, 0, 0, 0],\n        i,\n        self = this,\n        offset = self._nextSet(self._row),\n        isWhite = false,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        },\n        code,\n        error,\n        j,\n        sum;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                for (code = self.START_CODE_A; code <= self.START_CODE_C; code++) {\n                    error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n                    if (error < bestMatch.error) {\n                        bestMatch.code = code;\n                        bestMatch.error = error;\n                    }\n                }\n                if (bestMatch.error < self.AVG_CODE_ERROR) {\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    bestMatch.correction.bar = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.bar);\n                    bestMatch.correction.space = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.space);\n                    return bestMatch;\n                }\n\n                for ( j = 0; j < 4; j++) {\n                    counter[j] = counter[j + 2];\n                }\n                counter[4] = 0;\n                counter[5] = 0;\n                counterPos--;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nCode128Reader.prototype._decode = function() {\n    var self = this,\n        startInfo = self._findStart(),\n        code = null,\n        done = false,\n        result = [],\n        multiplier = 0,\n        checksum = 0,\n        codeset,\n        rawResult = [],\n        decodedCodes = [],\n        shiftNext = false,\n        unshift,\n        removeLastCharacter = true;\n\n    if (startInfo === null) {\n        return null;\n    }\n    code = {\n        code: startInfo.code,\n        start: startInfo.start,\n        end: startInfo.end,\n        correction: {\n            bar: startInfo.correction.bar,\n            space: startInfo.correction.space\n        }\n    };\n    decodedCodes.push(code);\n    checksum = code.code;\n    switch (code.code) {\n    case self.START_CODE_A:\n        codeset = self.CODE_A;\n        break;\n    case self.START_CODE_B:\n        codeset = self.CODE_B;\n        break;\n    case self.START_CODE_C:\n        codeset = self.CODE_C;\n        break;\n    default:\n        return null;\n    }\n\n    while (!done) {\n        unshift = shiftNext;\n        shiftNext = false;\n        code = self._decodeCode(code.end, code.correction);\n        if (code !== null) {\n            if (code.code !== self.STOP_CODE) {\n                removeLastCharacter = true;\n            }\n\n            if (code.code !== self.STOP_CODE) {\n                rawResult.push(code.code);\n                multiplier++;\n                checksum += multiplier * code.code;\n            }\n            decodedCodes.push(code);\n\n            switch (codeset) {\n            case self.CODE_A:\n                if (code.code < 64) {\n                    result.push(String.fromCharCode(32 + code.code));\n                } else if (code.code < 96) {\n                    result.push(String.fromCharCode(code.code - 64));\n                } else {\n                    if (code.code !== self.STOP_CODE) {\n                        removeLastCharacter = false;\n                    }\n                    switch (code.code) {\n                    case self.CODE_SHIFT:\n                        shiftNext = true;\n                        codeset = self.CODE_B;\n                        break;\n                    case self.CODE_B:\n                        codeset = self.CODE_B;\n                        break;\n                    case self.CODE_C:\n                        codeset = self.CODE_C;\n                        break;\n                    case self.STOP_CODE:\n                        done = true;\n                        break;\n                    }\n                }\n                break;\n            case self.CODE_B:\n                if (code.code < 96) {\n                    result.push(String.fromCharCode(32 + code.code));\n                } else {\n                    if (code.code !== self.STOP_CODE) {\n                        removeLastCharacter = false;\n                    }\n                    switch (code.code) {\n                    case self.CODE_SHIFT:\n                        shiftNext = true;\n                        codeset = self.CODE_A;\n                        break;\n                    case self.CODE_A:\n                        codeset = self.CODE_A;\n                        break;\n                    case self.CODE_C:\n                        codeset = self.CODE_C;\n                        break;\n                    case self.STOP_CODE:\n                        done = true;\n                        break;\n                    }\n                }\n                break;\n            case self.CODE_C:\n                if (code.code < 100) {\n                    result.push(code.code < 10 ? \"0\" + code.code : code.code);\n                } else {\n                    if (code.code !== self.STOP_CODE) {\n                        removeLastCharacter = false;\n                    }\n                    switch (code.code) {\n                    case self.CODE_A:\n                        codeset = self.CODE_A;\n                        break;\n                    case self.CODE_B:\n                        codeset = self.CODE_B;\n                        break;\n                    case self.STOP_CODE:\n                        done = true;\n                        break;\n                    }\n                }\n                break;\n            }\n        } else {\n            done = true;\n        }\n        if (unshift) {\n            codeset = codeset === self.CODE_A ? self.CODE_B : self.CODE_A;\n        }\n    }\n\n    if (code === null) {\n        return null;\n    }\n\n    code.end = self._nextUnset(self._row, code.end);\n    if (!self._verifyTrailingWhitespace(code)){\n        return null;\n    }\n\n    checksum -= multiplier * rawResult[rawResult.length - 1];\n    if (checksum % 103 !== rawResult[rawResult.length - 1]) {\n        return null;\n    }\n\n    if (!result.length) {\n        return null;\n    }\n\n    // remove last code from result (checksum)\n    if (removeLastCharacter) {\n        result.splice(result.length - 1, 1);\n    }\n\n\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: code.end,\n        codeset: codeset,\n        startInfo: startInfo,\n        decodedCodes: decodedCodes,\n        endInfo: code\n    };\n};\n\n\nBarcodeReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nfunction calculateCorrection(expected, normalized, indices) {\n    var length = indices.length,\n        sumNormalized = 0,\n        sumExpected = 0;\n\n    while(length--) {\n        sumExpected += expected[indices[length]];\n        sumNormalized += normalized[indices[length]];\n    }\n    return sumExpected/sumNormalized;\n}\n\nexport default Code128Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_128_reader.js","import Code39Reader from './code_39_reader';\n\nfunction Code39VINReader() {\n    Code39Reader.call(this);\n}\n\nvar patterns = {\n    IOQ: /[IOQ]/g,\n    AZ09: /[A-Z0-9]{17}/\n};\n\nCode39VINReader.prototype = Object.create(Code39Reader.prototype);\nCode39VINReader.prototype.constructor = Code39VINReader;\n\n// Cribbed from:\n// https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java\nCode39VINReader.prototype._decode = function() {\n    var result = Code39Reader.prototype._decode.apply(this);\n    if (!result) {\n        return null;\n    }\n\n    var code = result.code;\n\n    if (!code) {\n        return null;\n    }\n\n    code = code.replace(patterns.IOQ, '');\n\n    if (!code.match(patterns.AZ09)) {\n        if (ENV.development) {\n            console.log('Failed AZ09 pattern code:', code);\n        }\n        return null;\n    }\n\n    if (!this._checkChecksum(code)) {\n        return null;\n    }\n\n    result.code = code;\n    return result;\n};\n\nCode39VINReader.prototype._checkChecksum = function(code) {\n    // TODO\n    return !!code;\n};\n\nexport default Code39VINReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_39_vin_reader.js","import EANReader from './ean_reader';\n\nfunction EAN2Reader() {\n    EANReader.call(this);\n}\n\nvar properties = {\n    FORMAT: {value: \"ean_2\", writeable: false}\n};\n\nEAN2Reader.prototype = Object.create(EANReader.prototype, properties);\nEAN2Reader.prototype.constructor = EAN2Reader;\n\nEAN2Reader.prototype.decode = function(row, start) {\n    this._row = row;\n    var counters = [0, 0, 0, 0],\n        codeFrequency = 0,\n        i = 0,\n        offset = start,\n        end = this._row.length,\n        code,\n        result = [],\n        decodedCodes = [];\n\n    for (i = 0; i < 2 && offset < end; i++) {\n        code = this._decodeCode(offset);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code % 10);\n        if (code.code >= this.CODE_G_START) {\n            codeFrequency |= 1 << (1 - i);\n        }\n        if (i != 1) {\n            offset = this._nextSet(this._row, code.end);\n            offset = this._nextUnset(this._row, offset);\n        }\n    }\n\n    if (result.length != 2 || (parseInt(result.join(\"\")) % 4)  !== codeFrequency) {\n        return null;\n    }\n    return {\n        code: result.join(\"\"),\n        decodedCodes,\n        end: code.end\n    };\n};\n\nexport default EAN2Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_2_reader.js","import EANReader from './ean_reader';\n\nfunction EAN5Reader() {\n    EANReader.call(this);\n}\n\nvar properties = {\n    FORMAT: {value: \"ean_5\", writeable: false}\n};\n\nconst CHECK_DIGIT_ENCODINGS = [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];\n\nEAN5Reader.prototype = Object.create(EANReader.prototype, properties);\nEAN5Reader.prototype.constructor = EAN5Reader;\n\nEAN5Reader.prototype.decode = function(row, start) {\n    this._row = row;\n    var counters = [0, 0, 0, 0],\n        codeFrequency = 0,\n        i = 0,\n        offset = start,\n        end = this._row.length,\n        code,\n        result = [],\n        decodedCodes = [];\n\n    for (i = 0; i < 5 && offset < end; i++) {\n        code = this._decodeCode(offset);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code % 10);\n        if (code.code >= this.CODE_G_START) {\n            codeFrequency |= 1 << (4 - i);\n        }\n        if (i != 4) {\n            offset = this._nextSet(this._row, code.end);\n            offset = this._nextUnset(this._row, offset);\n        }\n    }\n\n    if (result.length != 5) {\n        return null;\n    }\n\n    if (extensionChecksum(result) !== determineCheckDigit(codeFrequency)) {\n        return null;\n    }\n    return {\n        code: result.join(\"\"),\n        decodedCodes,\n        end: code.end\n    };\n};\n\nfunction determineCheckDigit(codeFrequency) {\n    var i;\n    for (i = 0; i < 10; i++) {\n        if (codeFrequency === CHECK_DIGIT_ENCODINGS[i]) {\n            return i;\n        }\n    }\n    return null;\n}\n\n\nfunction extensionChecksum(result) {\n    var length = result.length,\n        sum = 0,\n        i;\n\n    for (i = length - 2; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    sum *= 3;\n    for (i = length - 1; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    sum *= 3;\n    return sum % 10;\n}\n\nexport default EAN5Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_5_reader.js","import EANReader from './ean_reader';\n\nfunction EAN8Reader(opts, supplements) {\n    EANReader.call(this, opts, supplements);\n}\n\nvar properties = {\n    FORMAT: {value: \"ean_8\", writeable: false}\n};\n\nEAN8Reader.prototype = Object.create(EANReader.prototype, properties);\nEAN8Reader.prototype.constructor = EAN8Reader;\n\nEAN8Reader.prototype._decodePayload = function(code, result, decodedCodes) {\n    var i,\n        self = this;\n\n    for ( i = 0; i < 4; i++) {\n        code = self._decodeCode(code.end, self.CODE_G_START);\n        if (!code) {\n            return null;\n        }\n        result.push(code.code);\n        decodedCodes.push(code);\n    }\n\n    code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);\n    if (code === null) {\n        return null;\n    }\n    decodedCodes.push(code);\n\n    for ( i = 0; i < 4; i++) {\n        code = self._decodeCode(code.end, self.CODE_G_START);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code);\n    }\n\n    return code;\n};\n\nexport default EAN8Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_8_reader.js","import BarcodeReader from './barcode_reader';\nimport {merge} from 'lodash';\n\nfunction I2of5Reader(opts) {\n    opts = merge(getDefaulConfig(), opts);\n    BarcodeReader.call(this, opts);\n    this.barSpaceRatio = [1, 1];\n    if (opts.normalizeBarSpaceWidth) {\n        this.SINGLE_CODE_ERROR = 0.38;\n        this.AVG_CODE_ERROR = 0.09;\n    }\n}\n\nfunction getDefaulConfig() {\n    var config = {};\n\n    Object.keys(I2of5Reader.CONFIG_KEYS).forEach(function(key) {\n        config[key] = I2of5Reader.CONFIG_KEYS[key].default;\n    });\n    return config;\n}\n\nvar N = 1,\n    W = 3,\n    properties = {\n        START_PATTERN: {value: [N, N, N, N]},\n        STOP_PATTERN: {value: [N, N, W]},\n        CODE_PATTERN: {value: [\n            [N, N, W, W, N],\n            [W, N, N, N, W],\n            [N, W, N, N, W],\n            [W, W, N, N, N],\n            [N, N, W, N, W],\n            [W, N, W, N, N],\n            [N, W, W, N, N],\n            [N, N, N, W, W],\n            [W, N, N, W, N],\n            [N, W, N, W, N]\n        ]},\n        SINGLE_CODE_ERROR: {value: 0.78, writable: true},\n        AVG_CODE_ERROR: {value: 0.38, writable: true},\n        MAX_CORRECTION_FACTOR: {value: 5},\n        FORMAT: {value: \"i2of5\"}\n    };\n\nI2of5Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nI2of5Reader.prototype.constructor = I2of5Reader;\n\nI2of5Reader.prototype._matchPattern = function(counter, code) {\n    if (this.config.normalizeBarSpaceWidth) {\n        var i,\n            counterSum = [0, 0],\n            codeSum = [0, 0],\n            correction = [0, 0],\n            correctionRatio = this.MAX_CORRECTION_FACTOR,\n            correctionRatioInverse = 1 / correctionRatio;\n\n        for (i = 0; i < counter.length; i++) {\n            counterSum[i % 2] += counter[i];\n            codeSum[i % 2] += code[i];\n        }\n        correction[0] = codeSum[0] / counterSum[0];\n        correction[1] = codeSum[1] / counterSum[1];\n\n        correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);\n        correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);\n        this.barSpaceRatio = correction;\n        for (i = 0; i < counter.length; i++) {\n            counter[i] *= this.barSpaceRatio[i % 2];\n        }\n    }\n    return BarcodeReader.prototype._matchPattern.call(this, counter, code);\n};\n\nI2of5Reader.prototype._findPattern = function(pattern, offset, isWhite, tryHarder) {\n    var counter = [],\n        self = this,\n        i,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        },\n        error,\n        j,\n        sum,\n        normalized,\n        epsilon = self.AVG_CODE_ERROR;\n\n    isWhite = isWhite || false;\n    tryHarder = tryHarder || false;\n\n    if (!offset) {\n        offset = self._nextSet(self._row);\n    }\n\n    for ( i = 0; i < pattern.length; i++) {\n        counter[i] = 0;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                error = self._matchPattern(counter, pattern);\n                if (error < epsilon) {\n                    bestMatch.error = error;\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    return bestMatch;\n                }\n                if (tryHarder) {\n                    for (j = 0; j < counter.length - 2; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[counter.length - 2] = 0;\n                    counter[counter.length - 1] = 0;\n                    counterPos--;\n                } else {\n                    return null;\n                }\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nI2of5Reader.prototype._findStart = function() {\n    var self = this,\n        leadingWhitespaceStart,\n        offset = self._nextSet(self._row),\n        startInfo,\n        narrowBarWidth = 1;\n\n    while (!startInfo) {\n        startInfo = self._findPattern(self.START_PATTERN, offset, false, true);\n        if (!startInfo) {\n            return null;\n        }\n        narrowBarWidth = Math.floor((startInfo.end - startInfo.start) / 4);\n        leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;\n        if (leadingWhitespaceStart >= 0) {\n            if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                return startInfo;\n            }\n        }\n        offset = startInfo.end;\n        startInfo = null;\n    }\n};\n\nI2of5Reader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nI2of5Reader.prototype._findEnd = function() {\n    var self = this,\n        endInfo,\n        tmp;\n\n    self._row.reverse();\n    endInfo = self._findPattern(self.STOP_PATTERN);\n    self._row.reverse();\n\n    if (endInfo === null) {\n        return null;\n    }\n\n    // reverse numbers\n    tmp = endInfo.start;\n    endInfo.start = self._row.length - endInfo.end;\n    endInfo.end = self._row.length - tmp;\n\n    return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;\n};\n\nI2of5Reader.prototype._decodePair = function(counterPair) {\n    var i,\n        code,\n        codes = [],\n        self = this;\n\n    for (i = 0; i < counterPair.length; i++) {\n        code = self._decodeCode(counterPair[i]);\n        if (!code) {\n            return null;\n        }\n        codes.push(code);\n    }\n    return codes;\n};\n\nI2of5Reader.prototype._decodeCode = function(counter) {\n    var j,\n        self = this,\n        sum = 0,\n        normalized,\n        error,\n        epsilon = self.AVG_CODE_ERROR,\n        code,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n    for ( j = 0; j < counter.length; j++) {\n        sum += counter[j];\n    }\n    for (code = 0; code < self.CODE_PATTERN.length; code++) {\n        error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n        if (error < bestMatch.error) {\n            bestMatch.code = code;\n            bestMatch.error = error;\n        }\n    }\n    if (bestMatch.error < epsilon) {\n        return bestMatch;\n    }\n};\n\nI2of5Reader.prototype._decodePayload = function(counters, result, decodedCodes) {\n    var i,\n        self = this,\n        pos = 0,\n        counterLength = counters.length,\n        counterPair = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],\n        codes;\n\n    while (pos < counterLength) {\n        for (i = 0; i < 5; i++) {\n            counterPair[0][i] = counters[pos] * this.barSpaceRatio[0];\n            counterPair[1][i] = counters[pos + 1] * this.barSpaceRatio[1];\n            pos += 2;\n        }\n        codes = self._decodePair(counterPair);\n        if (!codes) {\n            return null;\n        }\n        for (i = 0; i < codes.length; i++) {\n            result.push(codes[i].code + \"\");\n            decodedCodes.push(codes[i]);\n        }\n    }\n    return codes;\n};\n\nI2of5Reader.prototype._verifyCounterLength = function(counters) {\n    return (counters.length % 10 === 0);\n};\n\nI2of5Reader.prototype._decode = function() {\n    var startInfo,\n        endInfo,\n        self = this,\n        code,\n        result = [],\n        decodedCodes = [],\n        counters;\n\n    startInfo = self._findStart();\n    if (!startInfo) {\n        return null;\n    }\n    decodedCodes.push(startInfo);\n\n    endInfo = self._findEnd();\n    if (!endInfo) {\n        return null;\n    }\n\n    counters = self._fillCounters(startInfo.end, endInfo.start, false);\n    if (!self._verifyCounterLength(counters)) {\n        return null;\n    }\n    code = self._decodePayload(counters, result, decodedCodes);\n    if (!code) {\n        return null;\n    }\n    if (result.length % 2 !== 0 ||\n            result.length < 6) {\n        return null;\n    }\n\n    decodedCodes.push(endInfo);\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: endInfo.end,\n        startInfo: startInfo,\n        decodedCodes: decodedCodes\n    };\n};\n\nI2of5Reader.CONFIG_KEYS = {\n    normalizeBarSpaceWidth: {\n        'type': 'boolean',\n        'default': false,\n        'description': 'If true, the reader tries to normalize the' +\n        'width-difference between bars and spaces'\n    }\n};\n\nexport default I2of5Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/i2of5_reader.js","import EANReader from './ean_reader';\n\nfunction UPCEReader(opts, supplements) {\n    EANReader.call(this, opts, supplements);\n}\n\nvar properties = {\n    CODE_FREQUENCY: {value: [\n        [ 56, 52, 50, 49, 44, 38, 35, 42, 41, 37 ],\n        [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]]},\n    STOP_PATTERN: { value: [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7]},\n    FORMAT: {value: \"upc_e\", writeable: false}\n};\n\nUPCEReader.prototype = Object.create(EANReader.prototype, properties);\nUPCEReader.prototype.constructor = UPCEReader;\n\nUPCEReader.prototype._decodePayload = function(code, result, decodedCodes) {\n    var i,\n        self = this,\n        codeFrequency = 0x0;\n\n    for ( i = 0; i < 6; i++) {\n        code = self._decodeCode(code.end);\n        if (!code) {\n            return null;\n        }\n        if (code.code >= self.CODE_G_START) {\n            code.code = code.code - self.CODE_G_START;\n            codeFrequency |= 1 << (5 - i);\n        }\n        result.push(code.code);\n        decodedCodes.push(code);\n    }\n    if (!self._determineParity(codeFrequency, result)) {\n        return null;\n    }\n\n    return code;\n};\n\nUPCEReader.prototype._determineParity = function(codeFrequency, result) {\n    var i,\n        nrSystem;\n\n    for (nrSystem = 0; nrSystem < this.CODE_FREQUENCY.length; nrSystem++){\n        for ( i = 0; i < this.CODE_FREQUENCY[nrSystem].length; i++) {\n            if (codeFrequency === this.CODE_FREQUENCY[nrSystem][i]) {\n                result.unshift(nrSystem);\n                result.push(i);\n                return true;\n            }\n        }\n    }\n    return false;\n};\n\nUPCEReader.prototype._convertToUPCA = function(result) {\n    var upca = [result[0]],\n        lastDigit = result[result.length - 2];\n\n    if (lastDigit <= 2) {\n        upca = upca.concat(result.slice(1, 3))\n            .concat([lastDigit, 0, 0, 0, 0])\n            .concat(result.slice(3, 6));\n    } else if (lastDigit === 3) {\n        upca = upca.concat(result.slice(1, 4))\n            .concat([0, 0, 0, 0, 0])\n            .concat(result.slice(4, 6));\n    } else if (lastDigit === 4) {\n        upca = upca.concat(result.slice(1, 5))\n            .concat([0, 0, 0, 0, 0, result[5]]);\n    } else {\n        upca = upca.concat(result.slice(1, 6))\n            .concat([0, 0, 0, 0, lastDigit]);\n    }\n\n    upca.push(result[result.length - 1]);\n    return upca;\n};\n\nUPCEReader.prototype._checksum = function(result) {\n    return EANReader.prototype._checksum.call(this, this._convertToUPCA(result));\n};\n\nUPCEReader.prototype._findEnd = function(offset, isWhite) {\n    isWhite = true;\n    return EANReader.prototype._findEnd.call(this, offset, isWhite);\n};\n\nUPCEReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n};\n\nexport default UPCEReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/upc_e_reader.js","import EANReader from './ean_reader';\n\nfunction UPCReader(opts, supplements) {\n    EANReader.call(this, opts, supplements);\n}\n\nvar properties = {\n    FORMAT: {value: \"upc_a\", writeable: false}\n};\n\nUPCReader.prototype = Object.create(EANReader.prototype, properties);\nUPCReader.prototype.constructor = UPCReader;\n\nUPCReader.prototype._decode = function() {\n    var result = EANReader.prototype._decode.call(this);\n\n    if (result && result.code && result.code.length === 13 && result.code.charAt(0) === \"0\") {\n        result.code = result.code.substring(1);\n        return result;\n    }\n    return null;\n};\n\nexport default UPCReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/upc_reader.js","module.exports = copy\n\n/**\n * Copy the values from one mat2 to another\n *\n * @alias mat2.copy\n * @param {mat2} out the receiving matrix\n * @param {mat2} a the source matrix\n * @returns {mat2} out\n */\nfunction copy(out, a) {\n  out[0] = a[0]\n  out[1] = a[1]\n  out[2] = a[2]\n  out[3] = a[3]\n  return out\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-mat2/copy.js\n// module id = 97\n// module chunks = 0","module.exports = create\n\n/**\n * Creates a new identity mat2\n *\n * @alias mat2.create\n * @returns {mat2} a new 2x2 matrix\n */\nfunction create() {\n  var out = new Float32Array(4)\n  out[0] = 1\n  out[1] = 0\n  out[2] = 0\n  out[3] = 1\n  return out\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-mat2/create.js\n// module id = 98\n// module chunks = 0","module.exports = invert\n\n/**\n * Inverts a mat2\n *\n * @alias mat2.invert\n * @param {mat2} out the receiving matrix\n * @param {mat2} a the source matrix\n * @returns {mat2} out\n */\nfunction invert(out, a) {\n  var a0 = a[0]\n  var a1 = a[1]\n  var a2 = a[2]\n  var a3 = a[3]\n  var det = a0 * a3 - a2 * a1\n\n  if (!det) return null\n  det = 1.0 / det\n\n  out[0] =  a3 * det\n  out[1] = -a1 * det\n  out[2] = -a2 * det\n  out[3] =  a0 * det\n\n  return out\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-mat2/invert.js\n// module id = 99\n// module chunks = 0","module.exports = scale\n\n/**\n * Scales a vec2 by a scalar number\n *\n * @param {vec2} out the receiving vector\n * @param {vec2} a the vector to scale\n * @param {Number} b amount to scale the vector by\n * @returns {vec2} out\n */\nfunction scale(out, a, b) {\n    out[0] = a[0] * b\n    out[1] = a[1] * b\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/scale.js\n// module id = 100\n// module chunks = 0","module.exports = transformMat2\n\n/**\n * Transforms the vec2 with a mat2\n *\n * @param {vec2} out the receiving vector\n * @param {vec2} a the vector to transform\n * @param {mat2} m matrix to transform with\n * @returns {vec2} out\n */\nfunction transformMat2(out, a, m) {\n    var x = a[0],\n        y = a[1]\n    out[0] = m[0] * x + m[2] * y\n    out[1] = m[1] * x + m[3] * y\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/transformMat2.js\n// module id = 101\n// module chunks = 0","module.exports = clone;\n\n/**\n * Creates a new vec3 initialized with values from an existing vector\n *\n * @param {vec3} a vector to clone\n * @returns {vec3} a new 3D vector\n */\nfunction clone(a) {\n    var out = new Float32Array(3)\n    out[0] = a[0]\n    out[1] = a[1]\n    out[2] = a[2]\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec3/clone.js\n// module id = 102\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_DataView.js\n// module id = 103\n// module chunks = 0","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Hash.js\n// module id = 104\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Promise.js\n// module id = 105\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Set.js\n// module id = 106\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Uint8Array.js\n// module id = 107\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_WeakMap.js\n// module id = 108\n// module chunks = 0","/**\n * Adds the key-value `pair` to `map`.\n *\n * @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n */\nfunction addMapEntry(map, pair) {\n  // Don't return `map.set` because it's not chainable in IE 11.\n  map.set(pair[0], pair[1]);\n  return map;\n}\n\nmodule.exports = addMapEntry;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_addMapEntry.js\n// module id = 109\n// module chunks = 0","/**\n * Adds `value` to `set`.\n *\n * @private\n * @param {Object} set The set to modify.\n * @param {*} value The value to add.\n * @returns {Object} Returns `set`.\n */\nfunction addSetEntry(set, value) {\n  // Don't return `set.add` because it's not chainable in IE 11.\n  set.add(value);\n  return set;\n}\n\nmodule.exports = addSetEntry;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_addSetEntry.js\n// module id = 110\n// module chunks = 0","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_apply.js\n// module id = 111\n// module chunks = 0","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nmodule.exports = arrayEach;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayEach.js\n// module id = 112\n// module chunks = 0","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayFilter.js\n// module id = 113\n// module chunks = 0","var copyObject = require('./_copyObject'),\n    keys = require('./keys');\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseAssign.js\n// module id = 114\n// module chunks = 0","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssignIn(object, source) {\n  return object && copyObject(source, keysIn(source), object);\n}\n\nmodule.exports = baseAssignIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseAssignIn.js\n// module id = 115\n// module chunks = 0","var Stack = require('./_Stack'),\n    arrayEach = require('./_arrayEach'),\n    assignValue = require('./_assignValue'),\n    baseAssign = require('./_baseAssign'),\n    baseAssignIn = require('./_baseAssignIn'),\n    cloneBuffer = require('./_cloneBuffer'),\n    copyArray = require('./_copyArray'),\n    copySymbols = require('./_copySymbols'),\n    copySymbolsIn = require('./_copySymbolsIn'),\n    getAllKeys = require('./_getAllKeys'),\n    getAllKeysIn = require('./_getAllKeysIn'),\n    getTag = require('./_getTag'),\n    initCloneArray = require('./_initCloneArray'),\n    initCloneByTag = require('./_initCloneByTag'),\n    initCloneObject = require('./_initCloneObject'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isObject = require('./isObject'),\n    keys = require('./keys');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, baseClone, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nmodule.exports = baseClone;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseClone.js\n// module id = 116\n// module chunks = 0","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseCreate.js\n// module id = 117\n// module chunks = 0","var arrayPush = require('./_arrayPush'),\n    isFlattenable = require('./_isFlattenable');\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseFlatten;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseFlatten.js\n// module id = 118\n// module chunks = 0","var createBaseFor = require('./_createBaseFor');\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseFor.js\n// module id = 119\n// module chunks = 0","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n  return object != null && key in Object(object);\n}\n\nmodule.exports = baseHasIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseHasIn.js\n// module id = 120\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseIsArguments.js\n// module id = 121\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseIsNative.js\n// module id = 122\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseIsTypedArray.js\n// module id = 123\n// module chunks = 0","var isPrototype = require('./_isPrototype'),\n    nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseKeys.js\n// module id = 124\n// module chunks = 0","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseKeysIn.js\n// module id = 125\n// module chunks = 0","var Stack = require('./_Stack'),\n    assignMergeValue = require('./_assignMergeValue'),\n    baseFor = require('./_baseFor'),\n    baseMergeDeep = require('./_baseMergeDeep'),\n    isObject = require('./isObject'),\n    keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    if (isObject(srcValue)) {\n      stack || (stack = new Stack);\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(object[key], srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\nmodule.exports = baseMerge;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseMerge.js\n// module id = 126\n// module chunks = 0","var assignMergeValue = require('./_assignMergeValue'),\n    cloneBuffer = require('./_cloneBuffer'),\n    cloneTypedArray = require('./_cloneTypedArray'),\n    copyArray = require('./_copyArray'),\n    initCloneObject = require('./_initCloneObject'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLikeObject = require('./isArrayLikeObject'),\n    isBuffer = require('./isBuffer'),\n    isFunction = require('./isFunction'),\n    isObject = require('./isObject'),\n    isPlainObject = require('./isPlainObject'),\n    isTypedArray = require('./isTypedArray'),\n    toPlainObject = require('./toPlainObject');\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = object[key],\n      srcValue = source[key],\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\nmodule.exports = baseMergeDeep;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseMergeDeep.js\n// module id = 127\n// module chunks = 0","var basePickBy = require('./_basePickBy'),\n    hasIn = require('./hasIn');\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, paths) {\n  return basePickBy(object, paths, function(value, path) {\n    return hasIn(object, path);\n  });\n}\n\nmodule.exports = basePick;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_basePick.js\n// module id = 128\n// module chunks = 0","var baseGet = require('./_baseGet'),\n    baseSet = require('./_baseSet'),\n    castPath = require('./_castPath');\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n  var index = -1,\n      length = paths.length,\n      result = {};\n\n  while (++index < length) {\n    var path = paths[index],\n        value = baseGet(object, path);\n\n    if (predicate(value, path)) {\n      baseSet(result, castPath(path, object), value);\n    }\n  }\n  return result;\n}\n\nmodule.exports = basePickBy;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_basePickBy.js\n// module id = 129\n// module chunks = 0","var identity = require('./identity'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseRest.js\n// module id = 130\n// module chunks = 0","var assignValue = require('./_assignValue'),\n    castPath = require('./_castPath'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject'),\n    toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n  if (!isObject(object)) {\n    return object;\n  }\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      lastIndex = length - 1,\n      nested = object;\n\n  while (nested != null && ++index < length) {\n    var key = toKey(path[index]),\n        newValue = value;\n\n    if (index != lastIndex) {\n      var objValue = nested[key];\n      newValue = customizer ? customizer(objValue, key, nested) : undefined;\n      if (newValue === undefined) {\n        newValue = isObject(objValue)\n          ? objValue\n          : (isIndex(path[index + 1]) ? [] : {});\n      }\n    }\n    assignValue(nested, key, newValue);\n    nested = nested[key];\n  }\n  return object;\n}\n\nmodule.exports = baseSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseSet.js\n// module id = 131\n// module chunks = 0","var constant = require('./constant'),\n    defineProperty = require('./_defineProperty'),\n    identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nmodule.exports = baseSetToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseSetToString.js\n// module id = 132\n// module chunks = 0","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = end > length ? length : end;\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\nmodule.exports = baseSlice;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseSlice.js\n// module id = 133\n// module chunks = 0","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseTimes.js\n// module id = 134\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    arrayMap = require('./_arrayMap'),\n    isArray = require('./isArray'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isArray(value)) {\n    // Recursively convert values (susceptible to call stack limits).\n    return arrayMap(value, baseToString) + '';\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = baseToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseToString.js\n// module id = 135\n// module chunks = 0","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseUnary.js\n// module id = 136\n// module chunks = 0","var castPath = require('./_castPath'),\n    last = require('./last'),\n    parent = require('./_parent'),\n    toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.unset`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The property path to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n */\nfunction baseUnset(object, path) {\n  path = castPath(path, object);\n  object = parent(object, path);\n  return object == null || delete object[toKey(last(path))];\n}\n\nmodule.exports = baseUnset;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseUnset.js\n// module id = 137\n// module chunks = 0","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\nmodule.exports = cloneDataView;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneDataView.js\n// module id = 138\n// module chunks = 0","var addMapEntry = require('./_addMapEntry'),\n    arrayReduce = require('./_arrayReduce'),\n    mapToArray = require('./_mapToArray');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1;\n\n/**\n * Creates a clone of `map`.\n *\n * @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n */\nfunction cloneMap(map, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);\n  return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\nmodule.exports = cloneMap;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneMap.js\n// module id = 139\n// module chunks = 0","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\nmodule.exports = cloneRegExp;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneRegExp.js\n// module id = 140\n// module chunks = 0","var addSetEntry = require('./_addSetEntry'),\n    arrayReduce = require('./_arrayReduce'),\n    setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1;\n\n/**\n * Creates a clone of `set`.\n *\n * @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n */\nfunction cloneSet(set, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);\n  return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\nmodule.exports = cloneSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneSet.js\n// module id = 141\n// module chunks = 0","var Symbol = require('./_Symbol');\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\nmodule.exports = cloneSymbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneSymbol.js\n// module id = 142\n// module chunks = 0","var copyObject = require('./_copyObject'),\n    getSymbols = require('./_getSymbols');\n\n/**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\nmodule.exports = copySymbols;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_copySymbols.js\n// module id = 143\n// module chunks = 0","var copyObject = require('./_copyObject'),\n    getSymbolsIn = require('./_getSymbolsIn');\n\n/**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbolsIn(source, object) {\n  return copyObject(source, getSymbolsIn(source), object);\n}\n\nmodule.exports = copySymbolsIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_copySymbolsIn.js\n// module id = 144\n// module chunks = 0","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_coreJsData.js\n// module id = 145\n// module chunks = 0","var baseRest = require('./_baseRest'),\n    isIterateeCall = require('./_isIterateeCall');\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nmodule.exports = createAssigner;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_createAssigner.js\n// module id = 146\n// module chunks = 0","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nmodule.exports = createBaseFor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_createBaseFor.js\n// module id = 147\n// module chunks = 0","var isPlainObject = require('./isPlainObject');\n\n/**\n * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n * objects.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {string} key The key of the property to inspect.\n * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n */\nfunction customOmitClone(value) {\n  return isPlainObject(value) ? undefined : value;\n}\n\nmodule.exports = customOmitClone;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_customOmitClone.js\n// module id = 148\n// module chunks = 0","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbols = require('./_getSymbols'),\n    keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getAllKeys.js\n// module id = 149\n// module chunks = 0","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getRawTag.js\n// module id = 150\n// module chunks = 0","var DataView = require('./_DataView'),\n    Map = require('./_Map'),\n    Promise = require('./_Promise'),\n    Set = require('./_Set'),\n    WeakMap = require('./_WeakMap'),\n    baseGetTag = require('./_baseGetTag'),\n    toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nmodule.exports = getTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getTag.js\n// module id = 151\n// module chunks = 0","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getValue.js\n// module id = 152\n// module chunks = 0","var castPath = require('./_castPath'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isIndex = require('./_isIndex'),\n    isLength = require('./isLength'),\n    toKey = require('./_toKey');\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      result = false;\n\n  while (++index < length) {\n    var key = toKey(path[index]);\n    if (!(result = object != null && hasFunc(object, key))) {\n      break;\n    }\n    object = object[key];\n  }\n  if (result || ++index != length) {\n    return result;\n  }\n  length = object == null ? 0 : object.length;\n  return !!length && isLength(length) && isIndex(key, length) &&\n    (isArray(object) || isArguments(object));\n}\n\nmodule.exports = hasPath;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hasPath.js\n// module id = 153\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashClear.js\n// module id = 154\n// module chunks = 0","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashDelete.js\n// module id = 155\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashGet.js\n// module id = 156\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashHas.js\n// module id = 157\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashSet.js\n// module id = 158\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\nmodule.exports = initCloneArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_initCloneArray.js\n// module id = 159\n// module chunks = 0","var cloneArrayBuffer = require('./_cloneArrayBuffer'),\n    cloneDataView = require('./_cloneDataView'),\n    cloneMap = require('./_cloneMap'),\n    cloneRegExp = require('./_cloneRegExp'),\n    cloneSet = require('./_cloneSet'),\n    cloneSymbol = require('./_cloneSymbol'),\n    cloneTypedArray = require('./_cloneTypedArray');\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return cloneMap(object, isDeep, cloneFunc);\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return cloneSet(object, isDeep, cloneFunc);\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\nmodule.exports = initCloneByTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_initCloneByTag.js\n// module id = 160\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray');\n\n/** Built-in value references. */\nvar spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\nmodule.exports = isFlattenable;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isFlattenable.js\n// module id = 161\n// module chunks = 0","var eq = require('./eq'),\n    isArrayLike = require('./isArrayLike'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isIterateeCall.js\n// module id = 162\n// module chunks = 0","var isArray = require('./isArray'),\n    isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  if (isArray(value)) {\n    return false;\n  }\n  var type = typeof value;\n  if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n      value == null || isSymbol(value)) {\n    return true;\n  }\n  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n    (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isKey.js\n// module id = 163\n// module chunks = 0","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isKeyable.js\n// module id = 164\n// module chunks = 0","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isMasked.js\n// module id = 165\n// module chunks = 0","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheClear.js\n// module id = 166\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheDelete.js\n// module id = 167\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheGet.js\n// module id = 168\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheHas.js\n// module id = 169\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheSet.js\n// module id = 170\n// module chunks = 0","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheClear.js\n// module id = 171\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheDelete.js\n// module id = 172\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheGet.js\n// module id = 173\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheHas.js\n// module id = 174\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheSet.js\n// module id = 175\n// module chunks = 0","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nmodule.exports = mapToArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapToArray.js\n// module id = 176\n// module chunks = 0","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n  var result = memoize(func, function(key) {\n    if (cache.size === MAX_MEMOIZE_SIZE) {\n      cache.clear();\n    }\n    return key;\n  });\n\n  var cache = result.cache;\n  return result;\n}\n\nmodule.exports = memoizeCapped;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_memoizeCapped.js\n// module id = 177\n// module chunks = 0","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nativeKeys.js\n// module id = 178\n// module chunks = 0","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nativeKeysIn.js\n// module id = 179\n// module chunks = 0","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nodeUtil.js\n// module id = 180\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_objectToString.js\n// module id = 181\n// module chunks = 0","var baseGet = require('./_baseGet'),\n    baseSlice = require('./_baseSlice');\n\n/**\n * Gets the parent value at `path` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path to get the parent value of.\n * @returns {*} Returns the parent value.\n */\nfunction parent(object, path) {\n  return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n}\n\nmodule.exports = parent;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_parent.js\n// module id = 182\n// module chunks = 0","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nmodule.exports = setToArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_setToArray.js\n// module id = 183\n// module chunks = 0","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nmodule.exports = shortOut;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_shortOut.js\n// module id = 184\n// module chunks = 0","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackClear.js\n// module id = 185\n// module chunks = 0","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackDelete.js\n// module id = 186\n// module chunks = 0","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackGet.js\n// module id = 187\n// module chunks = 0","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackHas.js\n// module id = 188\n// module chunks = 0","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackSet.js\n// module id = 189\n// module chunks = 0","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar reLeadingDot = /^\\./,\n    rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n  var result = [];\n  if (reLeadingDot.test(string)) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, string) {\n    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\nmodule.exports = stringToPath;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stringToPath.js\n// module id = 190\n// module chunks = 0","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nmodule.exports = constant;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/constant.js\n// module id = 191\n// module chunks = 0","var baseFlatten = require('./_baseFlatten');\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? baseFlatten(array, 1) : [];\n}\n\nmodule.exports = flatten;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/flatten.js\n// module id = 192\n// module chunks = 0","var baseHasIn = require('./_baseHasIn'),\n    hasPath = require('./_hasPath');\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n  return object != null && hasPath(object, path, baseHasIn);\n}\n\nmodule.exports = hasIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/hasIn.js\n// module id = 193\n// module chunks = 0","var isArrayLike = require('./isArrayLike'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\nmodule.exports = isArrayLikeObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArrayLikeObject.js\n// module id = 194\n// module chunks = 0","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? array[length - 1] : undefined;\n}\n\nmodule.exports = last;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/last.js\n// module id = 195\n// module chunks = 0","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/memoize.js\n// module id = 196\n// module chunks = 0","var arrayMap = require('./_arrayMap'),\n    baseClone = require('./_baseClone'),\n    baseUnset = require('./_baseUnset'),\n    castPath = require('./_castPath'),\n    copyObject = require('./_copyObject'),\n    customOmitClone = require('./_customOmitClone'),\n    flatRest = require('./_flatRest'),\n    getAllKeysIn = require('./_getAllKeysIn');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable property paths of `object` that are not omitted.\n *\n * **Note:** This method is considerably slower than `_.pick`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\nvar omit = flatRest(function(object, paths) {\n  var result = {};\n  if (object == null) {\n    return result;\n  }\n  var isDeep = false;\n  paths = arrayMap(paths, function(path) {\n    path = castPath(path, object);\n    isDeep || (isDeep = path.length > 1);\n    return path;\n  });\n  copyObject(object, getAllKeysIn(object), result);\n  if (isDeep) {\n    result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n  }\n  var length = paths.length;\n  while (length--) {\n    baseUnset(result, paths[length]);\n  }\n  return result;\n});\n\nmodule.exports = omit;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/omit.js\n// module id = 197\n// module chunks = 0","var basePick = require('./_basePick'),\n    flatRest = require('./_flatRest');\n\n/**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\nvar pick = flatRest(function(object, paths) {\n  return object == null ? {} : basePick(object, paths);\n});\n\nmodule.exports = pick;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/pick.js\n// module id = 198\n// module chunks = 0","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/stubFalse.js\n// module id = 199\n// module chunks = 0","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\nmodule.exports = toPlainObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/toPlainObject.js\n// module id = 200\n// module chunks = 0","var baseToString = require('./_baseToString');\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\nmodule.exports = toString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/toString.js\n// module id = 201\n// module chunks = 0"," /* eslint-env node */\n'use strict';\n\n// SDP helpers.\nvar SDPUtils = {};\n\n// Generate an alphanumeric identifier for cname or mids.\n// TODO: use UUIDs instead? https://gist.github.com/jed/982883\nSDPUtils.generateIdentifier = function() {\n  return Math.random().toString(36).substr(2, 10);\n};\n\n// The RTCP CNAME used by all peerconnections from the same JS.\nSDPUtils.localCName = SDPUtils.generateIdentifier();\n\n// Splits SDP into lines, dealing with both CRLF and LF.\nSDPUtils.splitLines = function(blob) {\n  return blob.trim().split('\\n').map(function(line) {\n    return line.trim();\n  });\n};\n// Splits SDP into sessionpart and mediasections. Ensures CRLF.\nSDPUtils.splitSections = function(blob) {\n  var parts = blob.split('\\nm=');\n  return parts.map(function(part, index) {\n    return (index > 0 ? 'm=' + part : part).trim() + '\\r\\n';\n  });\n};\n\n// Returns lines that start with a certain prefix.\nSDPUtils.matchPrefix = function(blob, prefix) {\n  return SDPUtils.splitLines(blob).filter(function(line) {\n    return line.indexOf(prefix) === 0;\n  });\n};\n\n// Parses an ICE candidate line. Sample input:\n// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8\n// rport 55996\"\nSDPUtils.parseCandidate = function(line) {\n  var parts;\n  // Parse both variants.\n  if (line.indexOf('a=candidate:') === 0) {\n    parts = line.substring(12).split(' ');\n  } else {\n    parts = line.substring(10).split(' ');\n  }\n\n  var candidate = {\n    foundation: parts[0],\n    component: parts[1],\n    protocol: parts[2].toLowerCase(),\n    priority: parseInt(parts[3], 10),\n    ip: parts[4],\n    port: parseInt(parts[5], 10),\n    // skip parts[6] == 'typ'\n    type: parts[7]\n  };\n\n  for (var i = 8; i < parts.length; i += 2) {\n    switch (parts[i]) {\n      case 'raddr':\n        candidate.relatedAddress = parts[i + 1];\n        break;\n      case 'rport':\n        candidate.relatedPort = parseInt(parts[i + 1], 10);\n        break;\n      case 'tcptype':\n        candidate.tcpType = parts[i + 1];\n        break;\n      default: // Unknown extensions are silently ignored.\n        break;\n    }\n  }\n  return candidate;\n};\n\n// Translates a candidate object into SDP candidate attribute.\nSDPUtils.writeCandidate = function(candidate) {\n  var sdp = [];\n  sdp.push(candidate.foundation);\n  sdp.push(candidate.component);\n  sdp.push(candidate.protocol.toUpperCase());\n  sdp.push(candidate.priority);\n  sdp.push(candidate.ip);\n  sdp.push(candidate.port);\n\n  var type = candidate.type;\n  sdp.push('typ');\n  sdp.push(type);\n  if (type !== 'host' && candidate.relatedAddress &&\n      candidate.relatedPort) {\n    sdp.push('raddr');\n    sdp.push(candidate.relatedAddress); // was: relAddr\n    sdp.push('rport');\n    sdp.push(candidate.relatedPort); // was: relPort\n  }\n  if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {\n    sdp.push('tcptype');\n    sdp.push(candidate.tcpType);\n  }\n  return 'candidate:' + sdp.join(' ');\n};\n\n// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:\n// a=rtpmap:111 opus/48000/2\nSDPUtils.parseRtpMap = function(line) {\n  var parts = line.substr(9).split(' ');\n  var parsed = {\n    payloadType: parseInt(parts.shift(), 10) // was: id\n  };\n\n  parts = parts[0].split('/');\n\n  parsed.name = parts[0];\n  parsed.clockRate = parseInt(parts[1], 10); // was: clockrate\n  // was: channels\n  parsed.numChannels = parts.length === 3 ? parseInt(parts[2], 10) : 1;\n  return parsed;\n};\n\n// Generate an a=rtpmap line from RTCRtpCodecCapability or\n// RTCRtpCodecParameters.\nSDPUtils.writeRtpMap = function(codec) {\n  var pt = codec.payloadType;\n  if (codec.preferredPayloadType !== undefined) {\n    pt = codec.preferredPayloadType;\n  }\n  return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +\n      (codec.numChannels !== 1 ? '/' + codec.numChannels : '') + '\\r\\n';\n};\n\n// Parses an a=extmap line (headerextension from RFC 5285). Sample input:\n// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset\nSDPUtils.parseExtmap = function(line) {\n  var parts = line.substr(9).split(' ');\n  return {\n    id: parseInt(parts[0], 10),\n    uri: parts[1]\n  };\n};\n\n// Generates a=extmap line from RTCRtpHeaderExtensionParameters or\n// RTCRtpHeaderExtension.\nSDPUtils.writeExtmap = function(headerExtension) {\n  return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +\n       ' ' + headerExtension.uri + '\\r\\n';\n};\n\n// Parses an ftmp line, returns dictionary. Sample input:\n// a=fmtp:96 vbr=on;cng=on\n// Also deals with vbr=on; cng=on\nSDPUtils.parseFmtp = function(line) {\n  var parsed = {};\n  var kv;\n  var parts = line.substr(line.indexOf(' ') + 1).split(';');\n  for (var j = 0; j < parts.length; j++) {\n    kv = parts[j].trim().split('=');\n    parsed[kv[0].trim()] = kv[1];\n  }\n  return parsed;\n};\n\n// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.\nSDPUtils.writeFmtp = function(codec) {\n  var line = '';\n  var pt = codec.payloadType;\n  if (codec.preferredPayloadType !== undefined) {\n    pt = codec.preferredPayloadType;\n  }\n  if (codec.parameters && Object.keys(codec.parameters).length) {\n    var params = [];\n    Object.keys(codec.parameters).forEach(function(param) {\n      params.push(param + '=' + codec.parameters[param]);\n    });\n    line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\\r\\n';\n  }\n  return line;\n};\n\n// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:\n// a=rtcp-fb:98 nack rpsi\nSDPUtils.parseRtcpFb = function(line) {\n  var parts = line.substr(line.indexOf(' ') + 1).split(' ');\n  return {\n    type: parts.shift(),\n    parameter: parts.join(' ')\n  };\n};\n// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.\nSDPUtils.writeRtcpFb = function(codec) {\n  var lines = '';\n  var pt = codec.payloadType;\n  if (codec.preferredPayloadType !== undefined) {\n    pt = codec.preferredPayloadType;\n  }\n  if (codec.rtcpFeedback && codec.rtcpFeedback.length) {\n    // FIXME: special handling for trr-int?\n    codec.rtcpFeedback.forEach(function(fb) {\n      lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +\n      (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +\n          '\\r\\n';\n    });\n  }\n  return lines;\n};\n\n// Parses an RFC 5576 ssrc media attribute. Sample input:\n// a=ssrc:3735928559 cname:something\nSDPUtils.parseSsrcMedia = function(line) {\n  var sp = line.indexOf(' ');\n  var parts = {\n    ssrc: parseInt(line.substr(7, sp - 7), 10)\n  };\n  var colon = line.indexOf(':', sp);\n  if (colon > -1) {\n    parts.attribute = line.substr(sp + 1, colon - sp - 1);\n    parts.value = line.substr(colon + 1);\n  } else {\n    parts.attribute = line.substr(sp + 1);\n  }\n  return parts;\n};\n\n// Extracts DTLS parameters from SDP media section or sessionpart.\n// FIXME: for consistency with other functions this should only\n//   get the fingerprint line as input. See also getIceParameters.\nSDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {\n  var lines = SDPUtils.splitLines(mediaSection);\n  // Search in session part, too.\n  lines = lines.concat(SDPUtils.splitLines(sessionpart));\n  var fpLine = lines.filter(function(line) {\n    return line.indexOf('a=fingerprint:') === 0;\n  })[0].substr(14);\n  // Note: a=setup line is ignored since we use the 'auto' role.\n  var dtlsParameters = {\n    role: 'auto',\n    fingerprints: [{\n      algorithm: fpLine.split(' ')[0],\n      value: fpLine.split(' ')[1]\n    }]\n  };\n  return dtlsParameters;\n};\n\n// Serializes DTLS parameters to SDP.\nSDPUtils.writeDtlsParameters = function(params, setupType) {\n  var sdp = 'a=setup:' + setupType + '\\r\\n';\n  params.fingerprints.forEach(function(fp) {\n    sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\\r\\n';\n  });\n  return sdp;\n};\n// Parses ICE information from SDP media section or sessionpart.\n// FIXME: for consistency with other functions this should only\n//   get the ice-ufrag and ice-pwd lines as input.\nSDPUtils.getIceParameters = function(mediaSection, sessionpart) {\n  var lines = SDPUtils.splitLines(mediaSection);\n  // Search in session part, too.\n  lines = lines.concat(SDPUtils.splitLines(sessionpart));\n  var iceParameters = {\n    usernameFragment: lines.filter(function(line) {\n      return line.indexOf('a=ice-ufrag:') === 0;\n    })[0].substr(12),\n    password: lines.filter(function(line) {\n      return line.indexOf('a=ice-pwd:') === 0;\n    })[0].substr(10)\n  };\n  return iceParameters;\n};\n\n// Serializes ICE parameters to SDP.\nSDPUtils.writeIceParameters = function(params) {\n  return 'a=ice-ufrag:' + params.usernameFragment + '\\r\\n' +\n      'a=ice-pwd:' + params.password + '\\r\\n';\n};\n\n// Parses the SDP media section and returns RTCRtpParameters.\nSDPUtils.parseRtpParameters = function(mediaSection) {\n  var description = {\n    codecs: [],\n    headerExtensions: [],\n    fecMechanisms: [],\n    rtcp: []\n  };\n  var lines = SDPUtils.splitLines(mediaSection);\n  var mline = lines[0].split(' ');\n  for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]\n    var pt = mline[i];\n    var rtpmapline = SDPUtils.matchPrefix(\n        mediaSection, 'a=rtpmap:' + pt + ' ')[0];\n    if (rtpmapline) {\n      var codec = SDPUtils.parseRtpMap(rtpmapline);\n      var fmtps = SDPUtils.matchPrefix(\n          mediaSection, 'a=fmtp:' + pt + ' ');\n      // Only the first a=fmtp:<pt> is considered.\n      codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};\n      codec.rtcpFeedback = SDPUtils.matchPrefix(\n          mediaSection, 'a=rtcp-fb:' + pt + ' ')\n        .map(SDPUtils.parseRtcpFb);\n      description.codecs.push(codec);\n      // parse FEC mechanisms from rtpmap lines.\n      switch (codec.name.toUpperCase()) {\n        case 'RED':\n        case 'ULPFEC':\n          description.fecMechanisms.push(codec.name.toUpperCase());\n          break;\n        default: // only RED and ULPFEC are recognized as FEC mechanisms.\n          break;\n      }\n    }\n  }\n  SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {\n    description.headerExtensions.push(SDPUtils.parseExtmap(line));\n  });\n  // FIXME: parse rtcp.\n  return description;\n};\n\n// Generates parts of the SDP media section describing the capabilities /\n// parameters.\nSDPUtils.writeRtpDescription = function(kind, caps) {\n  var sdp = '';\n\n  // Build the mline.\n  sdp += 'm=' + kind + ' ';\n  sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.\n  sdp += ' UDP/TLS/RTP/SAVPF ';\n  sdp += caps.codecs.map(function(codec) {\n    if (codec.preferredPayloadType !== undefined) {\n      return codec.preferredPayloadType;\n    }\n    return codec.payloadType;\n  }).join(' ') + '\\r\\n';\n\n  sdp += 'c=IN IP4 0.0.0.0\\r\\n';\n  sdp += 'a=rtcp:9 IN IP4 0.0.0.0\\r\\n';\n\n  // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.\n  caps.codecs.forEach(function(codec) {\n    sdp += SDPUtils.writeRtpMap(codec);\n    sdp += SDPUtils.writeFmtp(codec);\n    sdp += SDPUtils.writeRtcpFb(codec);\n  });\n  var maxptime = 0;\n  caps.codecs.forEach(function(codec) {\n    if (codec.maxptime > maxptime) {\n      maxptime = codec.maxptime;\n    }\n  });\n  if (maxptime > 0) {\n    sdp += 'a=maxptime:' + maxptime + '\\r\\n';\n  }\n  sdp += 'a=rtcp-mux\\r\\n';\n\n  caps.headerExtensions.forEach(function(extension) {\n    sdp += SDPUtils.writeExtmap(extension);\n  });\n  // FIXME: write fecMechanisms.\n  return sdp;\n};\n\n// Parses the SDP media section and returns an array of\n// RTCRtpEncodingParameters.\nSDPUtils.parseRtpEncodingParameters = function(mediaSection) {\n  var encodingParameters = [];\n  var description = SDPUtils.parseRtpParameters(mediaSection);\n  var hasRed = description.fecMechanisms.indexOf('RED') !== -1;\n  var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;\n\n  // filter a=ssrc:... cname:, ignore PlanB-msid\n  var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n  .map(function(line) {\n    return SDPUtils.parseSsrcMedia(line);\n  })\n  .filter(function(parts) {\n    return parts.attribute === 'cname';\n  });\n  var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;\n  var secondarySsrc;\n\n  var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')\n  .map(function(line) {\n    var parts = line.split(' ');\n    parts.shift();\n    return parts.map(function(part) {\n      return parseInt(part, 10);\n    });\n  });\n  if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {\n    secondarySsrc = flows[0][1];\n  }\n\n  description.codecs.forEach(function(codec) {\n    if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {\n      var encParam = {\n        ssrc: primarySsrc,\n        codecPayloadType: parseInt(codec.parameters.apt, 10),\n        rtx: {\n          ssrc: secondarySsrc\n        }\n      };\n      encodingParameters.push(encParam);\n      if (hasRed) {\n        encParam = JSON.parse(JSON.stringify(encParam));\n        encParam.fec = {\n          ssrc: secondarySsrc,\n          mechanism: hasUlpfec ? 'red+ulpfec' : 'red'\n        };\n        encodingParameters.push(encParam);\n      }\n    }\n  });\n  if (encodingParameters.length === 0 && primarySsrc) {\n    encodingParameters.push({\n      ssrc: primarySsrc\n    });\n  }\n\n  // we support both b=AS and b=TIAS but interpret AS as TIAS.\n  var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');\n  if (bandwidth.length) {\n    if (bandwidth[0].indexOf('b=TIAS:') === 0) {\n      bandwidth = parseInt(bandwidth[0].substr(7), 10);\n    } else if (bandwidth[0].indexOf('b=AS:') === 0) {\n      bandwidth = parseInt(bandwidth[0].substr(5), 10);\n    }\n    encodingParameters.forEach(function(params) {\n      params.maxBitrate = bandwidth;\n    });\n  }\n  return encodingParameters;\n};\n\n// parses http://draft.ortc.org/#rtcrtcpparameters*\nSDPUtils.parseRtcpParameters = function(mediaSection) {\n  var rtcpParameters = {};\n\n  var cname;\n  // Gets the first SSRC. Note that with RTX there might be multiple\n  // SSRCs.\n  var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n      .map(function(line) {\n        return SDPUtils.parseSsrcMedia(line);\n      })\n      .filter(function(obj) {\n        return obj.attribute === 'cname';\n      })[0];\n  if (remoteSsrc) {\n    rtcpParameters.cname = remoteSsrc.value;\n    rtcpParameters.ssrc = remoteSsrc.ssrc;\n  }\n\n  // Edge uses the compound attribute instead of reducedSize\n  // compound is !reducedSize\n  var rsize = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-rsize');\n  rtcpParameters.reducedSize = rsize.length > 0;\n  rtcpParameters.compound = rsize.length === 0;\n\n  // parses the rtcp-mux attrіbute.\n  // Note that Edge does not support unmuxed RTCP.\n  var mux = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-mux');\n  rtcpParameters.mux = mux.length > 0;\n\n  return rtcpParameters;\n};\n\n// parses either a=msid: or a=ssrc:... msid lines an returns\n// the id of the MediaStream and MediaStreamTrack.\nSDPUtils.parseMsid = function(mediaSection) {\n  var parts;\n  var spec = SDPUtils.matchPrefix(mediaSection, 'a=msid:');\n  if (spec.length === 1) {\n    parts = spec[0].substr(7).split(' ');\n    return {stream: parts[0], track: parts[1]};\n  }\n  var planB = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n  .map(function(line) {\n    return SDPUtils.parseSsrcMedia(line);\n  })\n  .filter(function(parts) {\n    return parts.attribute === 'msid';\n  });\n  if (planB.length > 0) {\n    parts = planB[0].value.split(' ');\n    return {stream: parts[0], track: parts[1]};\n  }\n};\n\nSDPUtils.writeSessionBoilerplate = function() {\n  // FIXME: sess-id should be an NTP timestamp.\n  return 'v=0\\r\\n' +\n      'o=thisisadapterortc 8169639915646943137 2 IN IP4 127.0.0.1\\r\\n' +\n      's=-\\r\\n' +\n      't=0 0\\r\\n';\n};\n\nSDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {\n  var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);\n\n  // Map ICE parameters (ufrag, pwd) to SDP.\n  sdp += SDPUtils.writeIceParameters(\n      transceiver.iceGatherer.getLocalParameters());\n\n  // Map DTLS parameters to SDP.\n  sdp += SDPUtils.writeDtlsParameters(\n      transceiver.dtlsTransport.getLocalParameters(),\n      type === 'offer' ? 'actpass' : 'active');\n\n  sdp += 'a=mid:' + transceiver.mid + '\\r\\n';\n\n  if (transceiver.rtpSender && transceiver.rtpReceiver) {\n    sdp += 'a=sendrecv\\r\\n';\n  } else if (transceiver.rtpSender) {\n    sdp += 'a=sendonly\\r\\n';\n  } else if (transceiver.rtpReceiver) {\n    sdp += 'a=recvonly\\r\\n';\n  } else {\n    sdp += 'a=inactive\\r\\n';\n  }\n\n  if (transceiver.rtpSender) {\n    // spec.\n    var msid = 'msid:' + stream.id + ' ' +\n        transceiver.rtpSender.track.id + '\\r\\n';\n    sdp += 'a=' + msid;\n\n    // for Chrome.\n    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +\n        ' ' + msid;\n    if (transceiver.sendEncodingParameters[0].rtx) {\n      sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +\n          ' ' + msid;\n      sdp += 'a=ssrc-group:FID ' +\n          transceiver.sendEncodingParameters[0].ssrc + ' ' +\n          transceiver.sendEncodingParameters[0].rtx.ssrc +\n          '\\r\\n';\n    }\n  }\n  // FIXME: this should be written by writeRtpDescription.\n  sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +\n      ' cname:' + SDPUtils.localCName + '\\r\\n';\n  if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {\n    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +\n        ' cname:' + SDPUtils.localCName + '\\r\\n';\n  }\n  return sdp;\n};\n\n// Gets the direction from the mediaSection or the sessionpart.\nSDPUtils.getDirection = function(mediaSection, sessionpart) {\n  // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.\n  var lines = SDPUtils.splitLines(mediaSection);\n  for (var i = 0; i < lines.length; i++) {\n    switch (lines[i]) {\n      case 'a=sendrecv':\n      case 'a=sendonly':\n      case 'a=recvonly':\n      case 'a=inactive':\n        return lines[i].substr(2);\n      default:\n        // FIXME: What should happen here?\n    }\n  }\n  if (sessionpart) {\n    return SDPUtils.getDirection(sessionpart);\n  }\n  return 'sendrecv';\n};\n\nSDPUtils.getKind = function(mediaSection) {\n  var lines = SDPUtils.splitLines(mediaSection);\n  var mline = lines[0].split(' ');\n  return mline[0].substr(2);\n};\n\nSDPUtils.isRejected = function(mediaSection) {\n  return mediaSection.split(' ', 2)[1] === '0';\n};\n\n// Expose public methods.\nmodule.exports = SDPUtils;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/sdp/sdp.js\n// module id = 202\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n\n'use strict';\n\n// Shimming starts here.\n(function() {\n  // Utils.\n  var logging = require('./utils').log;\n  var browserDetails = require('./utils').browserDetails;\n  // Export to the adapter global object visible in the browser.\n  module.exports.browserDetails = browserDetails;\n  module.exports.extractVersion = require('./utils').extractVersion;\n  module.exports.disableLog = require('./utils').disableLog;\n\n  // Uncomment the line below if you want logging to occur, including logging\n  // for the switch statement below. Can also be turned on in the browser via\n  // adapter.disableLog(false), but then logging from the switch statement below\n  // will not appear.\n  // require('./utils').disableLog(false);\n\n  // Browser shims.\n  var chromeShim = require('./chrome/chrome_shim') || null;\n  var edgeShim = require('./edge/edge_shim') || null;\n  var firefoxShim = require('./firefox/firefox_shim') || null;\n  var safariShim = require('./safari/safari_shim') || null;\n\n  // Shim browser if found.\n  switch (browserDetails.browser) {\n    case 'opera': // fallthrough as it uses chrome shims\n    case 'chrome':\n      if (!chromeShim || !chromeShim.shimPeerConnection) {\n        logging('Chrome shim is not included in this adapter release.');\n        return;\n      }\n      logging('adapter.js shimming chrome.');\n      // Export to the adapter global object visible in the browser.\n      module.exports.browserShim = chromeShim;\n\n      chromeShim.shimGetUserMedia();\n      chromeShim.shimMediaStream();\n      chromeShim.shimSourceObject();\n      chromeShim.shimPeerConnection();\n      chromeShim.shimOnTrack();\n      break;\n    case 'firefox':\n      if (!firefoxShim || !firefoxShim.shimPeerConnection) {\n        logging('Firefox shim is not included in this adapter release.');\n        return;\n      }\n      logging('adapter.js shimming firefox.');\n      // Export to the adapter global object visible in the browser.\n      module.exports.browserShim = firefoxShim;\n\n      firefoxShim.shimGetUserMedia();\n      firefoxShim.shimSourceObject();\n      firefoxShim.shimPeerConnection();\n      firefoxShim.shimOnTrack();\n      break;\n    case 'edge':\n      if (!edgeShim || !edgeShim.shimPeerConnection) {\n        logging('MS edge shim is not included in this adapter release.');\n        return;\n      }\n      logging('adapter.js shimming edge.');\n      // Export to the adapter global object visible in the browser.\n      module.exports.browserShim = edgeShim;\n\n      edgeShim.shimGetUserMedia();\n      edgeShim.shimPeerConnection();\n      break;\n    case 'safari':\n      if (!safariShim) {\n        logging('Safari shim is not included in this adapter release.');\n        return;\n      }\n      logging('adapter.js shimming safari.');\n      // Export to the adapter global object visible in the browser.\n      module.exports.browserShim = safariShim;\n\n      safariShim.shimGetUserMedia();\n      break;\n    default:\n      logging('Unsupported browser!');\n  }\n})();\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/adapter_core.js\n// module id = 203\n// module chunks = 0","\n/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\nvar logging = require('../utils.js').log;\nvar browserDetails = require('../utils.js').browserDetails;\n\nvar chromeShim = {\n  shimMediaStream: function() {\n    window.MediaStream = window.MediaStream || window.webkitMediaStream;\n  },\n\n  shimOnTrack: function() {\n    if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in\n        window.RTCPeerConnection.prototype)) {\n      Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {\n        get: function() {\n          return this._ontrack;\n        },\n        set: function(f) {\n          var self = this;\n          if (this._ontrack) {\n            this.removeEventListener('track', this._ontrack);\n            this.removeEventListener('addstream', this._ontrackpoly);\n          }\n          this.addEventListener('track', this._ontrack = f);\n          this.addEventListener('addstream', this._ontrackpoly = function(e) {\n            // onaddstream does not fire when a track is added to an existing\n            // stream. But stream.onaddtrack is implemented so we use that.\n            e.stream.addEventListener('addtrack', function(te) {\n              var event = new Event('track');\n              event.track = te.track;\n              event.receiver = {track: te.track};\n              event.streams = [e.stream];\n              self.dispatchEvent(event);\n            });\n            e.stream.getTracks().forEach(function(track) {\n              var event = new Event('track');\n              event.track = track;\n              event.receiver = {track: track};\n              event.streams = [e.stream];\n              this.dispatchEvent(event);\n            }.bind(this));\n          }.bind(this));\n        }\n      });\n    }\n  },\n\n  shimSourceObject: function() {\n    if (typeof window === 'object') {\n      if (window.HTMLMediaElement &&\n        !('srcObject' in window.HTMLMediaElement.prototype)) {\n        // Shim the srcObject property, once, when HTMLMediaElement is found.\n        Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {\n          get: function() {\n            return this._srcObject;\n          },\n          set: function(stream) {\n            var self = this;\n            // Use _srcObject as a private property for this shim\n            this._srcObject = stream;\n            if (this.src) {\n              URL.revokeObjectURL(this.src);\n            }\n\n            if (!stream) {\n              this.src = '';\n              return;\n            }\n            this.src = URL.createObjectURL(stream);\n            // We need to recreate the blob url when a track is added or\n            // removed. Doing it manually since we want to avoid a recursion.\n            stream.addEventListener('addtrack', function() {\n              if (self.src) {\n                URL.revokeObjectURL(self.src);\n              }\n              self.src = URL.createObjectURL(stream);\n            });\n            stream.addEventListener('removetrack', function() {\n              if (self.src) {\n                URL.revokeObjectURL(self.src);\n              }\n              self.src = URL.createObjectURL(stream);\n            });\n          }\n        });\n      }\n    }\n  },\n\n  shimPeerConnection: function() {\n    // The RTCPeerConnection object.\n    window.RTCPeerConnection = function(pcConfig, pcConstraints) {\n      // Translate iceTransportPolicy to iceTransports,\n      // see https://code.google.com/p/webrtc/issues/detail?id=4869\n      logging('PeerConnection');\n      if (pcConfig && pcConfig.iceTransportPolicy) {\n        pcConfig.iceTransports = pcConfig.iceTransportPolicy;\n      }\n\n      var pc = new webkitRTCPeerConnection(pcConfig, pcConstraints);\n      var origGetStats = pc.getStats.bind(pc);\n      pc.getStats = function(selector, successCallback, errorCallback) {\n        var self = this;\n        var args = arguments;\n\n        // If selector is a function then we are in the old style stats so just\n        // pass back the original getStats format to avoid breaking old users.\n        if (arguments.length > 0 && typeof selector === 'function') {\n          return origGetStats(selector, successCallback);\n        }\n\n        var fixChromeStats_ = function(response) {\n          var standardReport = {};\n          var reports = response.result();\n          reports.forEach(function(report) {\n            var standardStats = {\n              id: report.id,\n              timestamp: report.timestamp,\n              type: report.type\n            };\n            report.names().forEach(function(name) {\n              standardStats[name] = report.stat(name);\n            });\n            standardReport[standardStats.id] = standardStats;\n          });\n\n          return standardReport;\n        };\n\n        // shim getStats with maplike support\n        var makeMapStats = function(stats, legacyStats) {\n          var map = new Map(Object.keys(stats).map(function(key) {\n            return[key, stats[key]];\n          }));\n          legacyStats = legacyStats || stats;\n          Object.keys(legacyStats).forEach(function(key) {\n            map[key] = legacyStats[key];\n          });\n          return map;\n        };\n\n        if (arguments.length >= 2) {\n          var successCallbackWrapper_ = function(response) {\n            args[1](makeMapStats(fixChromeStats_(response)));\n          };\n\n          return origGetStats.apply(this, [successCallbackWrapper_,\n              arguments[0]]);\n        }\n\n        // promise-support\n        return new Promise(function(resolve, reject) {\n          if (args.length === 1 && typeof selector === 'object') {\n            origGetStats.apply(self, [\n              function(response) {\n                resolve(makeMapStats(fixChromeStats_(response)));\n              }, reject]);\n          } else {\n            // Preserve legacy chrome stats only on legacy access of stats obj\n            origGetStats.apply(self, [\n              function(response) {\n                resolve(makeMapStats(fixChromeStats_(response),\n                    response.result()));\n              }, reject]);\n          }\n        }).then(successCallback, errorCallback);\n      };\n\n      return pc;\n    };\n    window.RTCPeerConnection.prototype = webkitRTCPeerConnection.prototype;\n\n    // wrap static methods. Currently just generateCertificate.\n    if (webkitRTCPeerConnection.generateCertificate) {\n      Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {\n        get: function() {\n          return webkitRTCPeerConnection.generateCertificate;\n        }\n      });\n    }\n\n    ['createOffer', 'createAnswer'].forEach(function(method) {\n      var nativeMethod = webkitRTCPeerConnection.prototype[method];\n      webkitRTCPeerConnection.prototype[method] = function() {\n        var self = this;\n        if (arguments.length < 1 || (arguments.length === 1 &&\n            typeof arguments[0] === 'object')) {\n          var opts = arguments.length === 1 ? arguments[0] : undefined;\n          return new Promise(function(resolve, reject) {\n            nativeMethod.apply(self, [resolve, reject, opts]);\n          });\n        }\n        return nativeMethod.apply(this, arguments);\n      };\n    });\n\n    // add promise support -- natively available in Chrome 51\n    if (browserDetails.version < 51) {\n      ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']\n          .forEach(function(method) {\n            var nativeMethod = webkitRTCPeerConnection.prototype[method];\n            webkitRTCPeerConnection.prototype[method] = function() {\n              var args = arguments;\n              var self = this;\n              var promise = new Promise(function(resolve, reject) {\n                nativeMethod.apply(self, [args[0], resolve, reject]);\n              });\n              if (args.length < 2) {\n                return promise;\n              }\n              return promise.then(function() {\n                args[1].apply(null, []);\n              },\n              function(err) {\n                if (args.length >= 3) {\n                  args[2].apply(null, [err]);\n                }\n              });\n            };\n          });\n    }\n\n    // shim implicit creation of RTCSessionDescription/RTCIceCandidate\n    ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']\n        .forEach(function(method) {\n          var nativeMethod = webkitRTCPeerConnection.prototype[method];\n          webkitRTCPeerConnection.prototype[method] = function() {\n            arguments[0] = new ((method === 'addIceCandidate') ?\n                RTCIceCandidate : RTCSessionDescription)(arguments[0]);\n            return nativeMethod.apply(this, arguments);\n          };\n        });\n\n    // support for addIceCandidate(null or undefined)\n    var nativeAddIceCandidate =\n        RTCPeerConnection.prototype.addIceCandidate;\n    RTCPeerConnection.prototype.addIceCandidate = function() {\n      if (!arguments[0]) {\n        if (arguments[1]) {\n          arguments[1].apply(null);\n        }\n        return Promise.resolve();\n      }\n      return nativeAddIceCandidate.apply(this, arguments);\n    };\n  }\n};\n\n\n// Expose public methods.\nmodule.exports = {\n  shimMediaStream: chromeShim.shimMediaStream,\n  shimOnTrack: chromeShim.shimOnTrack,\n  shimSourceObject: chromeShim.shimSourceObject,\n  shimPeerConnection: chromeShim.shimPeerConnection,\n  shimGetUserMedia: require('./getusermedia')\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/chrome/chrome_shim.js\n// module id = 204\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\nvar logging = require('../utils.js').log;\n\n// Expose public methods.\nmodule.exports = function() {\n  var constraintsToChrome_ = function(c) {\n    if (typeof c !== 'object' || c.mandatory || c.optional) {\n      return c;\n    }\n    var cc = {};\n    Object.keys(c).forEach(function(key) {\n      if (key === 'require' || key === 'advanced' || key === 'mediaSource') {\n        return;\n      }\n      var r = (typeof c[key] === 'object') ? c[key] : {ideal: c[key]};\n      if (r.exact !== undefined && typeof r.exact === 'number') {\n        r.min = r.max = r.exact;\n      }\n      var oldname_ = function(prefix, name) {\n        if (prefix) {\n          return prefix + name.charAt(0).toUpperCase() + name.slice(1);\n        }\n        return (name === 'deviceId') ? 'sourceId' : name;\n      };\n      if (r.ideal !== undefined) {\n        cc.optional = cc.optional || [];\n        var oc = {};\n        if (typeof r.ideal === 'number') {\n          oc[oldname_('min', key)] = r.ideal;\n          cc.optional.push(oc);\n          oc = {};\n          oc[oldname_('max', key)] = r.ideal;\n          cc.optional.push(oc);\n        } else {\n          oc[oldname_('', key)] = r.ideal;\n          cc.optional.push(oc);\n        }\n      }\n      if (r.exact !== undefined && typeof r.exact !== 'number') {\n        cc.mandatory = cc.mandatory || {};\n        cc.mandatory[oldname_('', key)] = r.exact;\n      } else {\n        ['min', 'max'].forEach(function(mix) {\n          if (r[mix] !== undefined) {\n            cc.mandatory = cc.mandatory || {};\n            cc.mandatory[oldname_(mix, key)] = r[mix];\n          }\n        });\n      }\n    });\n    if (c.advanced) {\n      cc.optional = (cc.optional || []).concat(c.advanced);\n    }\n    return cc;\n  };\n\n  var shimConstraints_ = function(constraints, func) {\n    constraints = JSON.parse(JSON.stringify(constraints));\n    if (constraints && constraints.audio) {\n      constraints.audio = constraintsToChrome_(constraints.audio);\n    }\n    if (constraints && typeof constraints.video === 'object') {\n      // Shim facingMode for mobile, where it defaults to \"user\".\n      var face = constraints.video.facingMode;\n      face = face && ((typeof face === 'object') ? face : {ideal: face});\n\n      if ((face && (face.exact === 'user' || face.exact === 'environment' ||\n                    face.ideal === 'user' || face.ideal === 'environment')) &&\n          !(navigator.mediaDevices.getSupportedConstraints &&\n            navigator.mediaDevices.getSupportedConstraints().facingMode)) {\n        delete constraints.video.facingMode;\n        if (face.exact === 'environment' || face.ideal === 'environment') {\n          // Look for \"back\" in label, or use last cam (typically back cam).\n          return navigator.mediaDevices.enumerateDevices()\n          .then(function(devices) {\n            devices = devices.filter(function(d) {\n              return d.kind === 'videoinput';\n            });\n            var back = devices.find(function(d) {\n              return d.label.toLowerCase().indexOf('back') !== -1;\n            }) || (devices.length && devices[devices.length - 1]);\n            if (back) {\n              constraints.video.deviceId = face.exact ? {exact: back.deviceId} :\n                                                        {ideal: back.deviceId};\n            }\n            constraints.video = constraintsToChrome_(constraints.video);\n            logging('chrome: ' + JSON.stringify(constraints));\n            return func(constraints);\n          });\n        }\n      }\n      constraints.video = constraintsToChrome_(constraints.video);\n    }\n    logging('chrome: ' + JSON.stringify(constraints));\n    return func(constraints);\n  };\n\n  var shimError_ = function(e) {\n    return {\n      name: {\n        PermissionDeniedError: 'NotAllowedError',\n        ConstraintNotSatisfiedError: 'OverconstrainedError'\n      }[e.name] || e.name,\n      message: e.message,\n      constraint: e.constraintName,\n      toString: function() {\n        return this.name + (this.message && ': ') + this.message;\n      }\n    };\n  };\n\n  var getUserMedia_ = function(constraints, onSuccess, onError) {\n    shimConstraints_(constraints, function(c) {\n      navigator.webkitGetUserMedia(c, onSuccess, function(e) {\n        onError(shimError_(e));\n      });\n    });\n  };\n\n  navigator.getUserMedia = getUserMedia_;\n\n  // Returns the result of getUserMedia as a Promise.\n  var getUserMediaPromise_ = function(constraints) {\n    return new Promise(function(resolve, reject) {\n      navigator.getUserMedia(constraints, resolve, reject);\n    });\n  };\n\n  if (!navigator.mediaDevices) {\n    navigator.mediaDevices = {\n      getUserMedia: getUserMediaPromise_,\n      enumerateDevices: function() {\n        return new Promise(function(resolve) {\n          var kinds = {audio: 'audioinput', video: 'videoinput'};\n          return MediaStreamTrack.getSources(function(devices) {\n            resolve(devices.map(function(device) {\n              return {label: device.label,\n                      kind: kinds[device.kind],\n                      deviceId: device.id,\n                      groupId: ''};\n            }));\n          });\n        });\n      }\n    };\n  }\n\n  // A shim for getUserMedia method on the mediaDevices object.\n  // TODO(KaptenJansson) remove once implemented in Chrome stable.\n  if (!navigator.mediaDevices.getUserMedia) {\n    navigator.mediaDevices.getUserMedia = function(constraints) {\n      return getUserMediaPromise_(constraints);\n    };\n  } else {\n    // Even though Chrome 45 has navigator.mediaDevices and a getUserMedia\n    // function which returns a Promise, it does not accept spec-style\n    // constraints.\n    var origGetUserMedia = navigator.mediaDevices.getUserMedia.\n        bind(navigator.mediaDevices);\n    navigator.mediaDevices.getUserMedia = function(cs) {\n      return shimConstraints_(cs, function(c) {\n        return origGetUserMedia(c).then(function(stream) {\n          if (c.audio && !stream.getAudioTracks().length ||\n              c.video && !stream.getVideoTracks().length) {\n            stream.getTracks().forEach(function(track) {\n              track.stop();\n            });\n            throw new DOMException('', 'NotFoundError');\n          }\n          return stream;\n        }, function(e) {\n          return Promise.reject(shimError_(e));\n        });\n      });\n    };\n  }\n\n  // Dummy devicechange event methods.\n  // TODO(KaptenJansson) remove once implemented in Chrome stable.\n  if (typeof navigator.mediaDevices.addEventListener === 'undefined') {\n    navigator.mediaDevices.addEventListener = function() {\n      logging('Dummy mediaDevices.addEventListener called.');\n    };\n  }\n  if (typeof navigator.mediaDevices.removeEventListener === 'undefined') {\n    navigator.mediaDevices.removeEventListener = function() {\n      logging('Dummy mediaDevices.removeEventListener called.');\n    };\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/chrome/getusermedia.js\n// module id = 205\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\n\nvar SDPUtils = require('sdp');\nvar browserDetails = require('../utils').browserDetails;\n\nvar edgeShim = {\n  shimPeerConnection: function() {\n    if (window.RTCIceGatherer) {\n      // ORTC defines an RTCIceCandidate object but no constructor.\n      // Not implemented in Edge.\n      if (!window.RTCIceCandidate) {\n        window.RTCIceCandidate = function(args) {\n          return args;\n        };\n      }\n      // ORTC does not have a session description object but\n      // other browsers (i.e. Chrome) that will support both PC and ORTC\n      // in the future might have this defined already.\n      if (!window.RTCSessionDescription) {\n        window.RTCSessionDescription = function(args) {\n          return args;\n        };\n      }\n      // this adds an additional event listener to MediaStrackTrack that signals\n      // when a tracks enabled property was changed.\n      var origMSTEnabled = Object.getOwnPropertyDescriptor(\n          MediaStreamTrack.prototype, 'enabled');\n      Object.defineProperty(MediaStreamTrack.prototype, 'enabled', {\n        set: function(value) {\n          origMSTEnabled.set.call(this, value);\n          var ev = new Event('enabled');\n          ev.enabled = value;\n          this.dispatchEvent(ev);\n        }\n      });\n    }\n\n    window.RTCPeerConnection = function(config) {\n      var self = this;\n\n      var _eventTarget = document.createDocumentFragment();\n      ['addEventListener', 'removeEventListener', 'dispatchEvent']\n          .forEach(function(method) {\n            self[method] = _eventTarget[method].bind(_eventTarget);\n          });\n\n      this.onicecandidate = null;\n      this.onaddstream = null;\n      this.ontrack = null;\n      this.onremovestream = null;\n      this.onsignalingstatechange = null;\n      this.oniceconnectionstatechange = null;\n      this.onnegotiationneeded = null;\n      this.ondatachannel = null;\n\n      this.localStreams = [];\n      this.remoteStreams = [];\n      this.getLocalStreams = function() {\n        return self.localStreams;\n      };\n      this.getRemoteStreams = function() {\n        return self.remoteStreams;\n      };\n\n      this.localDescription = new RTCSessionDescription({\n        type: '',\n        sdp: ''\n      });\n      this.remoteDescription = new RTCSessionDescription({\n        type: '',\n        sdp: ''\n      });\n      this.signalingState = 'stable';\n      this.iceConnectionState = 'new';\n      this.iceGatheringState = 'new';\n\n      this.iceOptions = {\n        gatherPolicy: 'all',\n        iceServers: []\n      };\n      if (config && config.iceTransportPolicy) {\n        switch (config.iceTransportPolicy) {\n          case 'all':\n          case 'relay':\n            this.iceOptions.gatherPolicy = config.iceTransportPolicy;\n            break;\n          case 'none':\n            // FIXME: remove once implementation and spec have added this.\n            throw new TypeError('iceTransportPolicy \"none\" not supported');\n          default:\n            // don't set iceTransportPolicy.\n            break;\n        }\n      }\n      this.usingBundle = config && config.bundlePolicy === 'max-bundle';\n\n      if (config && config.iceServers) {\n        // Edge does not like\n        // 1) stun:\n        // 2) turn: that does not have all of turn:host:port?transport=udp\n        // 3) turn: with ipv6 addresses\n        var iceServers = JSON.parse(JSON.stringify(config.iceServers));\n        this.iceOptions.iceServers = iceServers.filter(function(server) {\n          if (server && server.urls) {\n            var urls = server.urls;\n            if (typeof urls === 'string') {\n              urls = [urls];\n            }\n            urls = urls.filter(function(url) {\n              return (url.indexOf('turn:') === 0 &&\n                  url.indexOf('transport=udp') !== -1 &&\n                  url.indexOf('turn:[') === -1) ||\n                  (url.indexOf('stun:') === 0 &&\n                    browserDetails.version >= 14393);\n            })[0];\n            return !!urls;\n          }\n          return false;\n        });\n      }\n      this._config = config;\n\n      // per-track iceGathers, iceTransports, dtlsTransports, rtpSenders, ...\n      // everything that is needed to describe a SDP m-line.\n      this.transceivers = [];\n\n      // since the iceGatherer is currently created in createOffer but we\n      // must not emit candidates until after setLocalDescription we buffer\n      // them in this array.\n      this._localIceCandidatesBuffer = [];\n    };\n\n    window.RTCPeerConnection.prototype._emitBufferedCandidates = function() {\n      var self = this;\n      var sections = SDPUtils.splitSections(self.localDescription.sdp);\n      // FIXME: need to apply ice candidates in a way which is async but\n      // in-order\n      this._localIceCandidatesBuffer.forEach(function(event) {\n        var end = !event.candidate || Object.keys(event.candidate).length === 0;\n        if (end) {\n          for (var j = 1; j < sections.length; j++) {\n            if (sections[j].indexOf('\\r\\na=end-of-candidates\\r\\n') === -1) {\n              sections[j] += 'a=end-of-candidates\\r\\n';\n            }\n          }\n        } else if (event.candidate.candidate.indexOf('typ endOfCandidates')\n            === -1) {\n          sections[event.candidate.sdpMLineIndex + 1] +=\n              'a=' + event.candidate.candidate + '\\r\\n';\n        }\n        self.localDescription.sdp = sections.join('');\n        self.dispatchEvent(event);\n        if (self.onicecandidate !== null) {\n          self.onicecandidate(event);\n        }\n        if (!event.candidate && self.iceGatheringState !== 'complete') {\n          var complete = self.transceivers.every(function(transceiver) {\n            return transceiver.iceGatherer &&\n                transceiver.iceGatherer.state === 'completed';\n          });\n          if (complete) {\n            self.iceGatheringState = 'complete';\n          }\n        }\n      });\n      this._localIceCandidatesBuffer = [];\n    };\n\n    window.RTCPeerConnection.prototype.getConfiguration = function() {\n      return this._config;\n    };\n\n    window.RTCPeerConnection.prototype.addStream = function(stream) {\n      // Clone is necessary for local demos mostly, attaching directly\n      // to two different senders does not work (build 10547).\n      var clonedStream = stream.clone();\n      stream.getTracks().forEach(function(track, idx) {\n        var clonedTrack = clonedStream.getTracks()[idx];\n        track.addEventListener('enabled', function(event) {\n          clonedTrack.enabled = event.enabled;\n        });\n      });\n      this.localStreams.push(clonedStream);\n      this._maybeFireNegotiationNeeded();\n    };\n\n    window.RTCPeerConnection.prototype.removeStream = function(stream) {\n      var idx = this.localStreams.indexOf(stream);\n      if (idx > -1) {\n        this.localStreams.splice(idx, 1);\n        this._maybeFireNegotiationNeeded();\n      }\n    };\n\n    window.RTCPeerConnection.prototype.getSenders = function() {\n      return this.transceivers.filter(function(transceiver) {\n        return !!transceiver.rtpSender;\n      })\n      .map(function(transceiver) {\n        return transceiver.rtpSender;\n      });\n    };\n\n    window.RTCPeerConnection.prototype.getReceivers = function() {\n      return this.transceivers.filter(function(transceiver) {\n        return !!transceiver.rtpReceiver;\n      })\n      .map(function(transceiver) {\n        return transceiver.rtpReceiver;\n      });\n    };\n\n    // Determines the intersection of local and remote capabilities.\n    window.RTCPeerConnection.prototype._getCommonCapabilities =\n        function(localCapabilities, remoteCapabilities) {\n          var commonCapabilities = {\n            codecs: [],\n            headerExtensions: [],\n            fecMechanisms: []\n          };\n          localCapabilities.codecs.forEach(function(lCodec) {\n            for (var i = 0; i < remoteCapabilities.codecs.length; i++) {\n              var rCodec = remoteCapabilities.codecs[i];\n              if (lCodec.name.toLowerCase() === rCodec.name.toLowerCase() &&\n                  lCodec.clockRate === rCodec.clockRate) {\n                // number of channels is the highest common number of channels\n                rCodec.numChannels = Math.min(lCodec.numChannels,\n                    rCodec.numChannels);\n                // push rCodec so we reply with offerer payload type\n                commonCapabilities.codecs.push(rCodec);\n\n                // determine common feedback mechanisms\n                rCodec.rtcpFeedback = rCodec.rtcpFeedback.filter(function(fb) {\n                  for (var j = 0; j < lCodec.rtcpFeedback.length; j++) {\n                    if (lCodec.rtcpFeedback[j].type === fb.type &&\n                        lCodec.rtcpFeedback[j].parameter === fb.parameter) {\n                      return true;\n                    }\n                  }\n                  return false;\n                });\n                // FIXME: also need to determine .parameters\n                //  see https://github.com/openpeer/ortc/issues/569\n                break;\n              }\n            }\n          });\n\n          localCapabilities.headerExtensions\n              .forEach(function(lHeaderExtension) {\n                for (var i = 0; i < remoteCapabilities.headerExtensions.length;\n                     i++) {\n                  var rHeaderExtension = remoteCapabilities.headerExtensions[i];\n                  if (lHeaderExtension.uri === rHeaderExtension.uri) {\n                    commonCapabilities.headerExtensions.push(rHeaderExtension);\n                    break;\n                  }\n                }\n              });\n\n          // FIXME: fecMechanisms\n          return commonCapabilities;\n        };\n\n    // Create ICE gatherer, ICE transport and DTLS transport.\n    window.RTCPeerConnection.prototype._createIceAndDtlsTransports =\n        function(mid, sdpMLineIndex) {\n          var self = this;\n          var iceGatherer = new RTCIceGatherer(self.iceOptions);\n          var iceTransport = new RTCIceTransport(iceGatherer);\n          iceGatherer.onlocalcandidate = function(evt) {\n            var event = new Event('icecandidate');\n            event.candidate = {sdpMid: mid, sdpMLineIndex: sdpMLineIndex};\n\n            var cand = evt.candidate;\n            var end = !cand || Object.keys(cand).length === 0;\n            // Edge emits an empty object for RTCIceCandidateComplete‥\n            if (end) {\n              // polyfill since RTCIceGatherer.state is not implemented in\n              // Edge 10547 yet.\n              if (iceGatherer.state === undefined) {\n                iceGatherer.state = 'completed';\n              }\n\n              // Emit a candidate with type endOfCandidates to make the samples\n              // work. Edge requires addIceCandidate with this empty candidate\n              // to start checking. The real solution is to signal\n              // end-of-candidates to the other side when getting the null\n              // candidate but some apps (like the samples) don't do that.\n              event.candidate.candidate =\n                  'candidate:1 1 udp 1 0.0.0.0 9 typ endOfCandidates';\n            } else {\n              // RTCIceCandidate doesn't have a component, needs to be added\n              cand.component = iceTransport.component === 'RTCP' ? 2 : 1;\n              event.candidate.candidate = SDPUtils.writeCandidate(cand);\n            }\n\n            // update local description.\n            var sections = SDPUtils.splitSections(self.localDescription.sdp);\n            if (event.candidate.candidate.indexOf('typ endOfCandidates')\n                === -1) {\n              sections[event.candidate.sdpMLineIndex + 1] +=\n                  'a=' + event.candidate.candidate + '\\r\\n';\n            } else {\n              sections[event.candidate.sdpMLineIndex + 1] +=\n                  'a=end-of-candidates\\r\\n';\n            }\n            self.localDescription.sdp = sections.join('');\n\n            var complete = self.transceivers.every(function(transceiver) {\n              return transceiver.iceGatherer &&\n                  transceiver.iceGatherer.state === 'completed';\n            });\n\n            // Emit candidate if localDescription is set.\n            // Also emits null candidate when all gatherers are complete.\n            switch (self.iceGatheringState) {\n              case 'new':\n                self._localIceCandidatesBuffer.push(event);\n                if (end && complete) {\n                  self._localIceCandidatesBuffer.push(\n                      new Event('icecandidate'));\n                }\n                break;\n              case 'gathering':\n                self._emitBufferedCandidates();\n                self.dispatchEvent(event);\n                if (self.onicecandidate !== null) {\n                  self.onicecandidate(event);\n                }\n                if (complete) {\n                  self.dispatchEvent(new Event('icecandidate'));\n                  if (self.onicecandidate !== null) {\n                    self.onicecandidate(new Event('icecandidate'));\n                  }\n                  self.iceGatheringState = 'complete';\n                }\n                break;\n              case 'complete':\n                // should not happen... currently!\n                break;\n              default: // no-op.\n                break;\n            }\n          };\n          iceTransport.onicestatechange = function() {\n            self._updateConnectionState();\n          };\n\n          var dtlsTransport = new RTCDtlsTransport(iceTransport);\n          dtlsTransport.ondtlsstatechange = function() {\n            self._updateConnectionState();\n          };\n          dtlsTransport.onerror = function() {\n            // onerror does not set state to failed by itself.\n            dtlsTransport.state = 'failed';\n            self._updateConnectionState();\n          };\n\n          return {\n            iceGatherer: iceGatherer,\n            iceTransport: iceTransport,\n            dtlsTransport: dtlsTransport\n          };\n        };\n\n    // Start the RTP Sender and Receiver for a transceiver.\n    window.RTCPeerConnection.prototype._transceive = function(transceiver,\n        send, recv) {\n      var params = this._getCommonCapabilities(transceiver.localCapabilities,\n          transceiver.remoteCapabilities);\n      if (send && transceiver.rtpSender) {\n        params.encodings = transceiver.sendEncodingParameters;\n        params.rtcp = {\n          cname: SDPUtils.localCName\n        };\n        if (transceiver.recvEncodingParameters.length) {\n          params.rtcp.ssrc = transceiver.recvEncodingParameters[0].ssrc;\n        }\n        transceiver.rtpSender.send(params);\n      }\n      if (recv && transceiver.rtpReceiver) {\n        // remove RTX field in Edge 14942\n        if (transceiver.kind === 'video'\n            && transceiver.recvEncodingParameters) {\n          transceiver.recvEncodingParameters.forEach(function(p) {\n            delete p.rtx;\n          });\n        }\n        params.encodings = transceiver.recvEncodingParameters;\n        params.rtcp = {\n          cname: transceiver.cname\n        };\n        if (transceiver.sendEncodingParameters.length) {\n          params.rtcp.ssrc = transceiver.sendEncodingParameters[0].ssrc;\n        }\n        transceiver.rtpReceiver.receive(params);\n      }\n    };\n\n    window.RTCPeerConnection.prototype.setLocalDescription =\n        function(description) {\n          var self = this;\n          var sections;\n          var sessionpart;\n          if (description.type === 'offer') {\n            // FIXME: What was the purpose of this empty if statement?\n            // if (!this._pendingOffer) {\n            // } else {\n            if (this._pendingOffer) {\n              // VERY limited support for SDP munging. Limited to:\n              // * changing the order of codecs\n              sections = SDPUtils.splitSections(description.sdp);\n              sessionpart = sections.shift();\n              sections.forEach(function(mediaSection, sdpMLineIndex) {\n                var caps = SDPUtils.parseRtpParameters(mediaSection);\n                self._pendingOffer[sdpMLineIndex].localCapabilities = caps;\n              });\n              this.transceivers = this._pendingOffer;\n              delete this._pendingOffer;\n            }\n          } else if (description.type === 'answer') {\n            sections = SDPUtils.splitSections(self.remoteDescription.sdp);\n            sessionpart = sections.shift();\n            var isIceLite = SDPUtils.matchPrefix(sessionpart,\n                'a=ice-lite').length > 0;\n            sections.forEach(function(mediaSection, sdpMLineIndex) {\n              var transceiver = self.transceivers[sdpMLineIndex];\n              var iceGatherer = transceiver.iceGatherer;\n              var iceTransport = transceiver.iceTransport;\n              var dtlsTransport = transceiver.dtlsTransport;\n              var localCapabilities = transceiver.localCapabilities;\n              var remoteCapabilities = transceiver.remoteCapabilities;\n\n              var rejected = mediaSection.split('\\n', 1)[0]\n                  .split(' ', 2)[1] === '0';\n\n              if (!rejected && !transceiver.isDatachannel) {\n                var remoteIceParameters = SDPUtils.getIceParameters(\n                    mediaSection, sessionpart);\n                if (isIceLite) {\n                  var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')\n                  .map(function(cand) {\n                    return SDPUtils.parseCandidate(cand);\n                  })\n                  .filter(function(cand) {\n                    return cand.component === '1';\n                  });\n                  // ice-lite only includes host candidates in the SDP so we can\n                  // use setRemoteCandidates (which implies an\n                  // RTCIceCandidateComplete)\n                  if (cands.length) {\n                    iceTransport.setRemoteCandidates(cands);\n                  }\n                }\n                var remoteDtlsParameters = SDPUtils.getDtlsParameters(\n                    mediaSection, sessionpart);\n                if (isIceLite) {\n                  remoteDtlsParameters.role = 'server';\n                }\n\n                if (!self.usingBundle || sdpMLineIndex === 0) {\n                  iceTransport.start(iceGatherer, remoteIceParameters,\n                      isIceLite ? 'controlling' : 'controlled');\n                  dtlsTransport.start(remoteDtlsParameters);\n                }\n\n                // Calculate intersection of capabilities.\n                var params = self._getCommonCapabilities(localCapabilities,\n                    remoteCapabilities);\n\n                // Start the RTCRtpSender. The RTCRtpReceiver for this\n                // transceiver has already been started in setRemoteDescription.\n                self._transceive(transceiver,\n                    params.codecs.length > 0,\n                    false);\n              }\n            });\n          }\n\n          this.localDescription = {\n            type: description.type,\n            sdp: description.sdp\n          };\n          switch (description.type) {\n            case 'offer':\n              this._updateSignalingState('have-local-offer');\n              break;\n            case 'answer':\n              this._updateSignalingState('stable');\n              break;\n            default:\n              throw new TypeError('unsupported type \"' + description.type +\n                  '\"');\n          }\n\n          // If a success callback was provided, emit ICE candidates after it\n          // has been executed. Otherwise, emit callback after the Promise is\n          // resolved.\n          var hasCallback = arguments.length > 1 &&\n            typeof arguments[1] === 'function';\n          if (hasCallback) {\n            var cb = arguments[1];\n            window.setTimeout(function() {\n              cb();\n              if (self.iceGatheringState === 'new') {\n                self.iceGatheringState = 'gathering';\n              }\n              self._emitBufferedCandidates();\n            }, 0);\n          }\n          var p = Promise.resolve();\n          p.then(function() {\n            if (!hasCallback) {\n              if (self.iceGatheringState === 'new') {\n                self.iceGatheringState = 'gathering';\n              }\n              // Usually candidates will be emitted earlier.\n              window.setTimeout(self._emitBufferedCandidates.bind(self), 500);\n            }\n          });\n          return p;\n        };\n\n    window.RTCPeerConnection.prototype.setRemoteDescription =\n        function(description) {\n          var self = this;\n          var stream = new MediaStream();\n          var receiverList = [];\n          var sections = SDPUtils.splitSections(description.sdp);\n          var sessionpart = sections.shift();\n          var isIceLite = SDPUtils.matchPrefix(sessionpart,\n              'a=ice-lite').length > 0;\n          this.usingBundle = SDPUtils.matchPrefix(sessionpart,\n              'a=group:BUNDLE ').length > 0;\n          sections.forEach(function(mediaSection, sdpMLineIndex) {\n            var lines = SDPUtils.splitLines(mediaSection);\n            var mline = lines[0].substr(2).split(' ');\n            var kind = mline[0];\n            var rejected = mline[1] === '0';\n            var direction = SDPUtils.getDirection(mediaSection, sessionpart);\n\n            var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:');\n            if (mid.length) {\n              mid = mid[0].substr(6);\n            } else {\n              mid = SDPUtils.generateIdentifier();\n            }\n\n            // Reject datachannels which are not implemented yet.\n            if (kind === 'application' && mline[2] === 'DTLS/SCTP') {\n              self.transceivers[sdpMLineIndex] = {\n                mid: mid,\n                isDatachannel: true\n              };\n              return;\n            }\n\n            var transceiver;\n            var iceGatherer;\n            var iceTransport;\n            var dtlsTransport;\n            var rtpSender;\n            var rtpReceiver;\n            var sendEncodingParameters;\n            var recvEncodingParameters;\n            var localCapabilities;\n\n            var track;\n            // FIXME: ensure the mediaSection has rtcp-mux set.\n            var remoteCapabilities = SDPUtils.parseRtpParameters(mediaSection);\n            var remoteIceParameters;\n            var remoteDtlsParameters;\n            if (!rejected) {\n              remoteIceParameters = SDPUtils.getIceParameters(mediaSection,\n                  sessionpart);\n              remoteDtlsParameters = SDPUtils.getDtlsParameters(mediaSection,\n                  sessionpart);\n              remoteDtlsParameters.role = 'client';\n            }\n            recvEncodingParameters =\n                SDPUtils.parseRtpEncodingParameters(mediaSection);\n\n            var cname;\n            // Gets the first SSRC. Note that with RTX there might be multiple\n            // SSRCs.\n            var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n                .map(function(line) {\n                  return SDPUtils.parseSsrcMedia(line);\n                })\n                .filter(function(obj) {\n                  return obj.attribute === 'cname';\n                })[0];\n            if (remoteSsrc) {\n              cname = remoteSsrc.value;\n            }\n\n            var isComplete = SDPUtils.matchPrefix(mediaSection,\n                'a=end-of-candidates', sessionpart).length > 0;\n            var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')\n                .map(function(cand) {\n                  return SDPUtils.parseCandidate(cand);\n                })\n                .filter(function(cand) {\n                  return cand.component === '1';\n                });\n            if (description.type === 'offer' && !rejected) {\n              var transports = self.usingBundle && sdpMLineIndex > 0 ? {\n                iceGatherer: self.transceivers[0].iceGatherer,\n                iceTransport: self.transceivers[0].iceTransport,\n                dtlsTransport: self.transceivers[0].dtlsTransport\n              } : self._createIceAndDtlsTransports(mid, sdpMLineIndex);\n\n              if (isComplete) {\n                transports.iceTransport.setRemoteCandidates(cands);\n              }\n\n              localCapabilities = RTCRtpReceiver.getCapabilities(kind);\n\n              // filter RTX until additional stuff needed for RTX is implemented\n              // in adapter.js\n              localCapabilities.codecs = localCapabilities.codecs.filter(\n                  function(codec) {\n                    return codec.name !== 'rtx';\n                  });\n\n              sendEncodingParameters = [{\n                ssrc: (2 * sdpMLineIndex + 2) * 1001\n              }];\n\n              rtpReceiver = new RTCRtpReceiver(transports.dtlsTransport, kind);\n\n              track = rtpReceiver.track;\n              receiverList.push([track, rtpReceiver]);\n              // FIXME: not correct when there are multiple streams but that is\n              // not currently supported in this shim.\n              stream.addTrack(track);\n\n              // FIXME: look at direction.\n              if (self.localStreams.length > 0 &&\n                  self.localStreams[0].getTracks().length >= sdpMLineIndex) {\n                var localTrack;\n                if (kind === 'audio') {\n                  localTrack = self.localStreams[0].getAudioTracks()[0];\n                } else if (kind === 'video') {\n                  localTrack = self.localStreams[0].getVideoTracks()[0];\n                }\n                if (localTrack) {\n                  rtpSender = new RTCRtpSender(localTrack,\n                      transports.dtlsTransport);\n                }\n              }\n\n              self.transceivers[sdpMLineIndex] = {\n                iceGatherer: transports.iceGatherer,\n                iceTransport: transports.iceTransport,\n                dtlsTransport: transports.dtlsTransport,\n                localCapabilities: localCapabilities,\n                remoteCapabilities: remoteCapabilities,\n                rtpSender: rtpSender,\n                rtpReceiver: rtpReceiver,\n                kind: kind,\n                mid: mid,\n                cname: cname,\n                sendEncodingParameters: sendEncodingParameters,\n                recvEncodingParameters: recvEncodingParameters\n              };\n              // Start the RTCRtpReceiver now. The RTPSender is started in\n              // setLocalDescription.\n              self._transceive(self.transceivers[sdpMLineIndex],\n                  false,\n                  direction === 'sendrecv' || direction === 'sendonly');\n            } else if (description.type === 'answer' && !rejected) {\n              transceiver = self.transceivers[sdpMLineIndex];\n              iceGatherer = transceiver.iceGatherer;\n              iceTransport = transceiver.iceTransport;\n              dtlsTransport = transceiver.dtlsTransport;\n              rtpSender = transceiver.rtpSender;\n              rtpReceiver = transceiver.rtpReceiver;\n              sendEncodingParameters = transceiver.sendEncodingParameters;\n              localCapabilities = transceiver.localCapabilities;\n\n              self.transceivers[sdpMLineIndex].recvEncodingParameters =\n                  recvEncodingParameters;\n              self.transceivers[sdpMLineIndex].remoteCapabilities =\n                  remoteCapabilities;\n              self.transceivers[sdpMLineIndex].cname = cname;\n\n              if ((isIceLite || isComplete) && cands.length) {\n                iceTransport.setRemoteCandidates(cands);\n              }\n              if (!self.usingBundle || sdpMLineIndex === 0) {\n                iceTransport.start(iceGatherer, remoteIceParameters,\n                    'controlling');\n                dtlsTransport.start(remoteDtlsParameters);\n              }\n\n              self._transceive(transceiver,\n                  direction === 'sendrecv' || direction === 'recvonly',\n                  direction === 'sendrecv' || direction === 'sendonly');\n\n              if (rtpReceiver &&\n                  (direction === 'sendrecv' || direction === 'sendonly')) {\n                track = rtpReceiver.track;\n                receiverList.push([track, rtpReceiver]);\n                stream.addTrack(track);\n              } else {\n                // FIXME: actually the receiver should be created later.\n                delete transceiver.rtpReceiver;\n              }\n            }\n          });\n\n          this.remoteDescription = {\n            type: description.type,\n            sdp: description.sdp\n          };\n          switch (description.type) {\n            case 'offer':\n              this._updateSignalingState('have-remote-offer');\n              break;\n            case 'answer':\n              this._updateSignalingState('stable');\n              break;\n            default:\n              throw new TypeError('unsupported type \"' + description.type +\n                  '\"');\n          }\n          if (stream.getTracks().length) {\n            self.remoteStreams.push(stream);\n            window.setTimeout(function() {\n              var event = new Event('addstream');\n              event.stream = stream;\n              self.dispatchEvent(event);\n              if (self.onaddstream !== null) {\n                window.setTimeout(function() {\n                  self.onaddstream(event);\n                }, 0);\n              }\n\n              receiverList.forEach(function(item) {\n                var track = item[0];\n                var receiver = item[1];\n                var trackEvent = new Event('track');\n                trackEvent.track = track;\n                trackEvent.receiver = receiver;\n                trackEvent.streams = [stream];\n                self.dispatchEvent(event);\n                if (self.ontrack !== null) {\n                  window.setTimeout(function() {\n                    self.ontrack(trackEvent);\n                  }, 0);\n                }\n              });\n            }, 0);\n          }\n          if (arguments.length > 1 && typeof arguments[1] === 'function') {\n            window.setTimeout(arguments[1], 0);\n          }\n          return Promise.resolve();\n        };\n\n    window.RTCPeerConnection.prototype.close = function() {\n      this.transceivers.forEach(function(transceiver) {\n        /* not yet\n        if (transceiver.iceGatherer) {\n          transceiver.iceGatherer.close();\n        }\n        */\n        if (transceiver.iceTransport) {\n          transceiver.iceTransport.stop();\n        }\n        if (transceiver.dtlsTransport) {\n          transceiver.dtlsTransport.stop();\n        }\n        if (transceiver.rtpSender) {\n          transceiver.rtpSender.stop();\n        }\n        if (transceiver.rtpReceiver) {\n          transceiver.rtpReceiver.stop();\n        }\n      });\n      // FIXME: clean up tracks, local streams, remote streams, etc\n      this._updateSignalingState('closed');\n    };\n\n    // Update the signaling state.\n    window.RTCPeerConnection.prototype._updateSignalingState =\n        function(newState) {\n          this.signalingState = newState;\n          var event = new Event('signalingstatechange');\n          this.dispatchEvent(event);\n          if (this.onsignalingstatechange !== null) {\n            this.onsignalingstatechange(event);\n          }\n        };\n\n    // Determine whether to fire the negotiationneeded event.\n    window.RTCPeerConnection.prototype._maybeFireNegotiationNeeded =\n        function() {\n          // Fire away (for now).\n          var event = new Event('negotiationneeded');\n          this.dispatchEvent(event);\n          if (this.onnegotiationneeded !== null) {\n            this.onnegotiationneeded(event);\n          }\n        };\n\n    // Update the connection state.\n    window.RTCPeerConnection.prototype._updateConnectionState = function() {\n      var self = this;\n      var newState;\n      var states = {\n        'new': 0,\n        closed: 0,\n        connecting: 0,\n        checking: 0,\n        connected: 0,\n        completed: 0,\n        failed: 0\n      };\n      this.transceivers.forEach(function(transceiver) {\n        states[transceiver.iceTransport.state]++;\n        states[transceiver.dtlsTransport.state]++;\n      });\n      // ICETransport.completed and connected are the same for this purpose.\n      states.connected += states.completed;\n\n      newState = 'new';\n      if (states.failed > 0) {\n        newState = 'failed';\n      } else if (states.connecting > 0 || states.checking > 0) {\n        newState = 'connecting';\n      } else if (states.disconnected > 0) {\n        newState = 'disconnected';\n      } else if (states.new > 0) {\n        newState = 'new';\n      } else if (states.connected > 0 || states.completed > 0) {\n        newState = 'connected';\n      }\n\n      if (newState !== self.iceConnectionState) {\n        self.iceConnectionState = newState;\n        var event = new Event('iceconnectionstatechange');\n        this.dispatchEvent(event);\n        if (this.oniceconnectionstatechange !== null) {\n          this.oniceconnectionstatechange(event);\n        }\n      }\n    };\n\n    window.RTCPeerConnection.prototype.createOffer = function() {\n      var self = this;\n      if (this._pendingOffer) {\n        throw new Error('createOffer called while there is a pending offer.');\n      }\n      var offerOptions;\n      if (arguments.length === 1 && typeof arguments[0] !== 'function') {\n        offerOptions = arguments[0];\n      } else if (arguments.length === 3) {\n        offerOptions = arguments[2];\n      }\n\n      var tracks = [];\n      var numAudioTracks = 0;\n      var numVideoTracks = 0;\n      // Default to sendrecv.\n      if (this.localStreams.length) {\n        numAudioTracks = this.localStreams[0].getAudioTracks().length;\n        numVideoTracks = this.localStreams[0].getVideoTracks().length;\n      }\n      // Determine number of audio and video tracks we need to send/recv.\n      if (offerOptions) {\n        // Reject Chrome legacy constraints.\n        if (offerOptions.mandatory || offerOptions.optional) {\n          throw new TypeError(\n              'Legacy mandatory/optional constraints not supported.');\n        }\n        if (offerOptions.offerToReceiveAudio !== undefined) {\n          numAudioTracks = offerOptions.offerToReceiveAudio;\n        }\n        if (offerOptions.offerToReceiveVideo !== undefined) {\n          numVideoTracks = offerOptions.offerToReceiveVideo;\n        }\n      }\n      if (this.localStreams.length) {\n        // Push local streams.\n        this.localStreams[0].getTracks().forEach(function(track) {\n          tracks.push({\n            kind: track.kind,\n            track: track,\n            wantReceive: track.kind === 'audio' ?\n                numAudioTracks > 0 : numVideoTracks > 0\n          });\n          if (track.kind === 'audio') {\n            numAudioTracks--;\n          } else if (track.kind === 'video') {\n            numVideoTracks--;\n          }\n        });\n      }\n      // Create M-lines for recvonly streams.\n      while (numAudioTracks > 0 || numVideoTracks > 0) {\n        if (numAudioTracks > 0) {\n          tracks.push({\n            kind: 'audio',\n            wantReceive: true\n          });\n          numAudioTracks--;\n        }\n        if (numVideoTracks > 0) {\n          tracks.push({\n            kind: 'video',\n            wantReceive: true\n          });\n          numVideoTracks--;\n        }\n      }\n\n      var sdp = SDPUtils.writeSessionBoilerplate();\n      var transceivers = [];\n      tracks.forEach(function(mline, sdpMLineIndex) {\n        // For each track, create an ice gatherer, ice transport,\n        // dtls transport, potentially rtpsender and rtpreceiver.\n        var track = mline.track;\n        var kind = mline.kind;\n        var mid = SDPUtils.generateIdentifier();\n\n        var transports = self.usingBundle && sdpMLineIndex > 0 ? {\n          iceGatherer: transceivers[0].iceGatherer,\n          iceTransport: transceivers[0].iceTransport,\n          dtlsTransport: transceivers[0].dtlsTransport\n        } : self._createIceAndDtlsTransports(mid, sdpMLineIndex);\n\n        var localCapabilities = RTCRtpSender.getCapabilities(kind);\n        // filter RTX until additional stuff needed for RTX is implemented\n        // in adapter.js\n        localCapabilities.codecs = localCapabilities.codecs.filter(\n            function(codec) {\n              return codec.name !== 'rtx';\n            });\n        localCapabilities.codecs.forEach(function(codec) {\n          // work around https://bugs.chromium.org/p/webrtc/issues/detail?id=6552\n          // by adding level-asymmetry-allowed=1\n          if (codec.name === 'H264' &&\n              codec.parameters['level-asymmetry-allowed'] === undefined) {\n            codec.parameters['level-asymmetry-allowed'] = '1';\n          }\n        });\n\n        var rtpSender;\n        var rtpReceiver;\n\n        // generate an ssrc now, to be used later in rtpSender.send\n        var sendEncodingParameters = [{\n          ssrc: (2 * sdpMLineIndex + 1) * 1001\n        }];\n        if (track) {\n          rtpSender = new RTCRtpSender(track, transports.dtlsTransport);\n        }\n\n        if (mline.wantReceive) {\n          rtpReceiver = new RTCRtpReceiver(transports.dtlsTransport, kind);\n        }\n\n        transceivers[sdpMLineIndex] = {\n          iceGatherer: transports.iceGatherer,\n          iceTransport: transports.iceTransport,\n          dtlsTransport: transports.dtlsTransport,\n          localCapabilities: localCapabilities,\n          remoteCapabilities: null,\n          rtpSender: rtpSender,\n          rtpReceiver: rtpReceiver,\n          kind: kind,\n          mid: mid,\n          sendEncodingParameters: sendEncodingParameters,\n          recvEncodingParameters: null\n        };\n      });\n      if (this.usingBundle) {\n        sdp += 'a=group:BUNDLE ' + transceivers.map(function(t) {\n          return t.mid;\n        }).join(' ') + '\\r\\n';\n      }\n      tracks.forEach(function(mline, sdpMLineIndex) {\n        var transceiver = transceivers[sdpMLineIndex];\n        sdp += SDPUtils.writeMediaSection(transceiver,\n            transceiver.localCapabilities, 'offer', self.localStreams[0]);\n      });\n\n      this._pendingOffer = transceivers;\n      var desc = new RTCSessionDescription({\n        type: 'offer',\n        sdp: sdp\n      });\n      if (arguments.length && typeof arguments[0] === 'function') {\n        window.setTimeout(arguments[0], 0, desc);\n      }\n      return Promise.resolve(desc);\n    };\n\n    window.RTCPeerConnection.prototype.createAnswer = function() {\n      var self = this;\n\n      var sdp = SDPUtils.writeSessionBoilerplate();\n      if (this.usingBundle) {\n        sdp += 'a=group:BUNDLE ' + this.transceivers.map(function(t) {\n          return t.mid;\n        }).join(' ') + '\\r\\n';\n      }\n      this.transceivers.forEach(function(transceiver) {\n        if (transceiver.isDatachannel) {\n          sdp += 'm=application 0 DTLS/SCTP 5000\\r\\n' +\n              'c=IN IP4 0.0.0.0\\r\\n' +\n              'a=mid:' + transceiver.mid + '\\r\\n';\n          return;\n        }\n        // Calculate intersection of capabilities.\n        var commonCapabilities = self._getCommonCapabilities(\n            transceiver.localCapabilities,\n            transceiver.remoteCapabilities);\n\n        sdp += SDPUtils.writeMediaSection(transceiver, commonCapabilities,\n            'answer', self.localStreams[0]);\n      });\n\n      var desc = new RTCSessionDescription({\n        type: 'answer',\n        sdp: sdp\n      });\n      if (arguments.length && typeof arguments[0] === 'function') {\n        window.setTimeout(arguments[0], 0, desc);\n      }\n      return Promise.resolve(desc);\n    };\n\n    window.RTCPeerConnection.prototype.addIceCandidate = function(candidate) {\n      if (!candidate) {\n        this.transceivers.forEach(function(transceiver) {\n          transceiver.iceTransport.addRemoteCandidate({});\n        });\n      } else {\n        var mLineIndex = candidate.sdpMLineIndex;\n        if (candidate.sdpMid) {\n          for (var i = 0; i < this.transceivers.length; i++) {\n            if (this.transceivers[i].mid === candidate.sdpMid) {\n              mLineIndex = i;\n              break;\n            }\n          }\n        }\n        var transceiver = this.transceivers[mLineIndex];\n        if (transceiver) {\n          var cand = Object.keys(candidate.candidate).length > 0 ?\n              SDPUtils.parseCandidate(candidate.candidate) : {};\n          // Ignore Chrome's invalid candidates since Edge does not like them.\n          if (cand.protocol === 'tcp' && (cand.port === 0 || cand.port === 9)) {\n            return;\n          }\n          // Ignore RTCP candidates, we assume RTCP-MUX.\n          if (cand.component !== '1') {\n            return;\n          }\n          // A dirty hack to make samples work.\n          if (cand.type === 'endOfCandidates') {\n            cand = {};\n          }\n          transceiver.iceTransport.addRemoteCandidate(cand);\n\n          // update the remoteDescription.\n          var sections = SDPUtils.splitSections(this.remoteDescription.sdp);\n          sections[mLineIndex + 1] += (cand.type ? candidate.candidate.trim()\n              : 'a=end-of-candidates') + '\\r\\n';\n          this.remoteDescription.sdp = sections.join('');\n        }\n      }\n      if (arguments.length > 1 && typeof arguments[1] === 'function') {\n        window.setTimeout(arguments[1], 0);\n      }\n      return Promise.resolve();\n    };\n\n    window.RTCPeerConnection.prototype.getStats = function() {\n      var promises = [];\n      this.transceivers.forEach(function(transceiver) {\n        ['rtpSender', 'rtpReceiver', 'iceGatherer', 'iceTransport',\n            'dtlsTransport'].forEach(function(method) {\n              if (transceiver[method]) {\n                promises.push(transceiver[method].getStats());\n              }\n            });\n      });\n      var cb = arguments.length > 1 && typeof arguments[1] === 'function' &&\n          arguments[1];\n      return new Promise(function(resolve) {\n        // shim getStats with maplike support\n        var results = new Map();\n        Promise.all(promises).then(function(res) {\n          res.forEach(function(result) {\n            Object.keys(result).forEach(function(id) {\n              results.set(id, result[id]);\n              results[id] = result[id];\n            });\n          });\n          if (cb) {\n            window.setTimeout(cb, 0, results);\n          }\n          resolve(results);\n        });\n      });\n    };\n  }\n};\n\n// Expose public methods.\nmodule.exports = {\n  shimPeerConnection: edgeShim.shimPeerConnection,\n  shimGetUserMedia: require('./getusermedia')\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/edge/edge_shim.js\n// module id = 206\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\n\n// Expose public methods.\nmodule.exports = function() {\n  var shimError_ = function(e) {\n    return {\n      name: {PermissionDeniedError: 'NotAllowedError'}[e.name] || e.name,\n      message: e.message,\n      constraint: e.constraint,\n      toString: function() {\n        return this.name;\n      }\n    };\n  };\n\n  // getUserMedia error shim.\n  var origGetUserMedia = navigator.mediaDevices.getUserMedia.\n      bind(navigator.mediaDevices);\n  navigator.mediaDevices.getUserMedia = function(c) {\n    return origGetUserMedia(c).catch(function(e) {\n      return Promise.reject(shimError_(e));\n    });\n  };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/edge/getusermedia.js\n// module id = 207\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\n\nvar browserDetails = require('../utils').browserDetails;\n\nvar firefoxShim = {\n  shimOnTrack: function() {\n    if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in\n        window.RTCPeerConnection.prototype)) {\n      Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {\n        get: function() {\n          return this._ontrack;\n        },\n        set: function(f) {\n          if (this._ontrack) {\n            this.removeEventListener('track', this._ontrack);\n            this.removeEventListener('addstream', this._ontrackpoly);\n          }\n          this.addEventListener('track', this._ontrack = f);\n          this.addEventListener('addstream', this._ontrackpoly = function(e) {\n            e.stream.getTracks().forEach(function(track) {\n              var event = new Event('track');\n              event.track = track;\n              event.receiver = {track: track};\n              event.streams = [e.stream];\n              this.dispatchEvent(event);\n            }.bind(this));\n          }.bind(this));\n        }\n      });\n    }\n  },\n\n  shimSourceObject: function() {\n    // Firefox has supported mozSrcObject since FF22, unprefixed in 42.\n    if (typeof window === 'object') {\n      if (window.HTMLMediaElement &&\n        !('srcObject' in window.HTMLMediaElement.prototype)) {\n        // Shim the srcObject property, once, when HTMLMediaElement is found.\n        Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {\n          get: function() {\n            return this.mozSrcObject;\n          },\n          set: function(stream) {\n            this.mozSrcObject = stream;\n          }\n        });\n      }\n    }\n  },\n\n  shimPeerConnection: function() {\n    if (typeof window !== 'object' || !(window.RTCPeerConnection ||\n        window.mozRTCPeerConnection)) {\n      return; // probably media.peerconnection.enabled=false in about:config\n    }\n    // The RTCPeerConnection object.\n    if (!window.RTCPeerConnection) {\n      window.RTCPeerConnection = function(pcConfig, pcConstraints) {\n        if (browserDetails.version < 38) {\n          // .urls is not supported in FF < 38.\n          // create RTCIceServers with a single url.\n          if (pcConfig && pcConfig.iceServers) {\n            var newIceServers = [];\n            for (var i = 0; i < pcConfig.iceServers.length; i++) {\n              var server = pcConfig.iceServers[i];\n              if (server.hasOwnProperty('urls')) {\n                for (var j = 0; j < server.urls.length; j++) {\n                  var newServer = {\n                    url: server.urls[j]\n                  };\n                  if (server.urls[j].indexOf('turn') === 0) {\n                    newServer.username = server.username;\n                    newServer.credential = server.credential;\n                  }\n                  newIceServers.push(newServer);\n                }\n              } else {\n                newIceServers.push(pcConfig.iceServers[i]);\n              }\n            }\n            pcConfig.iceServers = newIceServers;\n          }\n        }\n        return new mozRTCPeerConnection(pcConfig, pcConstraints);\n      };\n      window.RTCPeerConnection.prototype = mozRTCPeerConnection.prototype;\n\n      // wrap static methods. Currently just generateCertificate.\n      if (mozRTCPeerConnection.generateCertificate) {\n        Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {\n          get: function() {\n            return mozRTCPeerConnection.generateCertificate;\n          }\n        });\n      }\n\n      window.RTCSessionDescription = mozRTCSessionDescription;\n      window.RTCIceCandidate = mozRTCIceCandidate;\n    }\n\n    // shim away need for obsolete RTCIceCandidate/RTCSessionDescription.\n    ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']\n        .forEach(function(method) {\n          var nativeMethod = RTCPeerConnection.prototype[method];\n          RTCPeerConnection.prototype[method] = function() {\n            arguments[0] = new ((method === 'addIceCandidate') ?\n                RTCIceCandidate : RTCSessionDescription)(arguments[0]);\n            return nativeMethod.apply(this, arguments);\n          };\n        });\n\n    // support for addIceCandidate(null or undefined)\n    var nativeAddIceCandidate =\n        RTCPeerConnection.prototype.addIceCandidate;\n    RTCPeerConnection.prototype.addIceCandidate = function() {\n      if (!arguments[0]) {\n        if (arguments[1]) {\n          arguments[1].apply(null);\n        }\n        return Promise.resolve();\n      }\n      return nativeAddIceCandidate.apply(this, arguments);\n    };\n\n    if (browserDetails.version < 48) {\n      // shim getStats with maplike support\n      var makeMapStats = function(stats) {\n        var map = new Map();\n        Object.keys(stats).forEach(function(key) {\n          map.set(key, stats[key]);\n          map[key] = stats[key];\n        });\n        return map;\n      };\n\n      var nativeGetStats = RTCPeerConnection.prototype.getStats;\n      RTCPeerConnection.prototype.getStats = function(selector, onSucc, onErr) {\n        return nativeGetStats.apply(this, [selector || null])\n          .then(function(stats) {\n            return makeMapStats(stats);\n          })\n          .then(onSucc, onErr);\n      };\n    }\n  }\n};\n\n// Expose public methods.\nmodule.exports = {\n  shimOnTrack: firefoxShim.shimOnTrack,\n  shimSourceObject: firefoxShim.shimSourceObject,\n  shimPeerConnection: firefoxShim.shimPeerConnection,\n  shimGetUserMedia: require('./getusermedia')\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/firefox/firefox_shim.js\n// module id = 208\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n /* eslint-env node */\n'use strict';\n\nvar logging = require('../utils').log;\nvar browserDetails = require('../utils').browserDetails;\n\n// Expose public methods.\nmodule.exports = function() {\n  var shimError_ = function(e) {\n    return {\n      name: {\n        SecurityError: 'NotAllowedError',\n        PermissionDeniedError: 'NotAllowedError'\n      }[e.name] || e.name,\n      message: {\n        'The operation is insecure.': 'The request is not allowed by the ' +\n        'user agent or the platform in the current context.'\n      }[e.message] || e.message,\n      constraint: e.constraint,\n      toString: function() {\n        return this.name + (this.message && ': ') + this.message;\n      }\n    };\n  };\n\n  // getUserMedia constraints shim.\n  var getUserMedia_ = function(constraints, onSuccess, onError) {\n    var constraintsToFF37_ = function(c) {\n      if (typeof c !== 'object' || c.require) {\n        return c;\n      }\n      var require = [];\n      Object.keys(c).forEach(function(key) {\n        if (key === 'require' || key === 'advanced' || key === 'mediaSource') {\n          return;\n        }\n        var r = c[key] = (typeof c[key] === 'object') ?\n            c[key] : {ideal: c[key]};\n        if (r.min !== undefined ||\n            r.max !== undefined || r.exact !== undefined) {\n          require.push(key);\n        }\n        if (r.exact !== undefined) {\n          if (typeof r.exact === 'number') {\n            r. min = r.max = r.exact;\n          } else {\n            c[key] = r.exact;\n          }\n          delete r.exact;\n        }\n        if (r.ideal !== undefined) {\n          c.advanced = c.advanced || [];\n          var oc = {};\n          if (typeof r.ideal === 'number') {\n            oc[key] = {min: r.ideal, max: r.ideal};\n          } else {\n            oc[key] = r.ideal;\n          }\n          c.advanced.push(oc);\n          delete r.ideal;\n          if (!Object.keys(r).length) {\n            delete c[key];\n          }\n        }\n      });\n      if (require.length) {\n        c.require = require;\n      }\n      return c;\n    };\n    constraints = JSON.parse(JSON.stringify(constraints));\n    if (browserDetails.version < 38) {\n      logging('spec: ' + JSON.stringify(constraints));\n      if (constraints.audio) {\n        constraints.audio = constraintsToFF37_(constraints.audio);\n      }\n      if (constraints.video) {\n        constraints.video = constraintsToFF37_(constraints.video);\n      }\n      logging('ff37: ' + JSON.stringify(constraints));\n    }\n    return navigator.mozGetUserMedia(constraints, onSuccess, function(e) {\n      onError(shimError_(e));\n    });\n  };\n\n  // Returns the result of getUserMedia as a Promise.\n  var getUserMediaPromise_ = function(constraints) {\n    return new Promise(function(resolve, reject) {\n      getUserMedia_(constraints, resolve, reject);\n    });\n  };\n\n  // Shim for mediaDevices on older versions.\n  if (!navigator.mediaDevices) {\n    navigator.mediaDevices = {getUserMedia: getUserMediaPromise_,\n      addEventListener: function() { },\n      removeEventListener: function() { }\n    };\n  }\n  navigator.mediaDevices.enumerateDevices =\n      navigator.mediaDevices.enumerateDevices || function() {\n        return new Promise(function(resolve) {\n          var infos = [\n            {kind: 'audioinput', deviceId: 'default', label: '', groupId: ''},\n            {kind: 'videoinput', deviceId: 'default', label: '', groupId: ''}\n          ];\n          resolve(infos);\n        });\n      };\n\n  if (browserDetails.version < 41) {\n    // Work around http://bugzil.la/1169665\n    var orgEnumerateDevices =\n        navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);\n    navigator.mediaDevices.enumerateDevices = function() {\n      return orgEnumerateDevices().then(undefined, function(e) {\n        if (e.name === 'NotFoundError') {\n          return [];\n        }\n        throw e;\n      });\n    };\n  }\n  if (browserDetails.version < 49) {\n    var origGetUserMedia = navigator.mediaDevices.getUserMedia.\n        bind(navigator.mediaDevices);\n    navigator.mediaDevices.getUserMedia = function(c) {\n      return origGetUserMedia(c).then(function(stream) {\n        // Work around https://bugzil.la/802326\n        if (c.audio && !stream.getAudioTracks().length ||\n            c.video && !stream.getVideoTracks().length) {\n          stream.getTracks().forEach(function(track) {\n            track.stop();\n          });\n          throw new DOMException('The object can not be found here.',\n                                 'NotFoundError');\n        }\n        return stream;\n      }, function(e) {\n        return Promise.reject(shimError_(e));\n      });\n    };\n  }\n  navigator.getUserMedia = function(constraints, onSuccess, onError) {\n    if (browserDetails.version < 44) {\n      return getUserMedia_(constraints, onSuccess, onError);\n    }\n    // Replace Firefox 44+'s deprecation warning with unprefixed version.\n    console.warn('navigator.getUserMedia has been replaced by ' +\n                 'navigator.mediaDevices.getUserMedia');\n    navigator.mediaDevices.getUserMedia(constraints).then(onSuccess, onError);\n  };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/firefox/getusermedia.js\n// module id = 209\n// module chunks = 0","/*\n *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.\n *\n *  Use of this source code is governed by a BSD-style license\n *  that can be found in the LICENSE file in the root of the source\n *  tree.\n */\n'use strict';\nvar safariShim = {\n  // TODO: DrAlex, should be here, double check against LayoutTests\n  // shimOnTrack: function() { },\n\n  // TODO: once the back-end for the mac port is done, add.\n  // TODO: check for webkitGTK+\n  // shimPeerConnection: function() { },\n\n  shimGetUserMedia: function() {\n    navigator.getUserMedia = navigator.webkitGetUserMedia;\n  }\n};\n\n// Expose public methods.\nmodule.exports = {\n  shimGetUserMedia: safariShim.shimGetUserMedia\n  // TODO\n  // shimOnTrack: safariShim.shimOnTrack,\n  // shimPeerConnection: safariShim.shimPeerConnection\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/webrtc-adapter/src/js/safari/safari_shim.js\n// module id = 210\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_211__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"get-pixels\"\n// module id = 211\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_212__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"ndarray\"\n// module id = 212\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_213__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"ndarray-linear-interpolate\"\n// module id = 213\n// module chunks = 0"],"sourceRoot":""} |